/* eslint-disable */
/* This is an auto-generated file, do not edit manually */
import { EntityClient } from "../client/entity.client";
import { BaseClient } from "../client/base.client";
import type {
  ClientConfig,
  FindManyArgs,
  FindUniqueArgs,
  CreateArgs,
  UpdateArgs,
  DeleteArgs,
  QueryOptions,
  SelectionMap,
  IncludeMap,
} from "../client/types";
import { parse as gql } from "graphql";
import type { DocumentNode } from "graphql";
import type * as Types from "./base-types";
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends { [key: string]: unknown }> = {
  [K in keyof T]: T[K];
};
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
  [SubKey in K]?: Maybe<T[SubKey]>;
};
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
  [SubKey in K]: Maybe<T[SubKey]>;
};
export type MakeEmpty<
  T extends { [key: string]: unknown },
  K extends keyof T,
> = { [_ in K]?: never };
export type Incremental<T> =
  | T
  | {
      [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never;
    };

// Selection type helpers
type RecursivePartial<T> = {
  [P in keyof T]?: T[P] extends (infer U)[]
    ? RecursivePartial<U>[]
    : T[P] extends object
      ? RecursivePartial<T[P]>
      : T[P];
};

type QuerySelections<T> = {
  select?: SelectionMap<T>;
  include?: IncludeMap<T>;
};

/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: { input: string; output: string };
  String: { input: string; output: string };
  Boolean: { input: boolean; output: boolean };
  Int: { input: number; output: number };
  Float: { input: number; output: number };
  access_level: { input: any; output: any };
  address_type: { input: any; output: any };
  app_plan_enum: { input: any; output: any };
  app_role_enum: { input: any; output: any };
  bigint: { input: any; output: any };
  complexity_level: { input: any; output: any };
  contact_type: { input: any; output: any };
  content_status: { input: any; output: any };
  content_type: { input: any; output: any };
  date: { input: any; output: any };
  error_severity: { input: any; output: any };
  error_type: { input: any; output: any };
  feedback_status: { input: any; output: any };
  feedback_type: { input: any; output: any };
  float8: { input: any; output: any };
  followed_entity: { input: any; output: any };
  inet: { input: any; output: any };
  interval: { input: any; output: any };
  job_status: { input: any; output: any };
  jsonb: { input: any; output: any };
  lquery: { input: any; output: any };
  ltree: { input: any; output: any };
  ltxtquery: { input: any; output: any };
  numeric: { input: any; output: any };
  priority: { input: any; output: any };
  privacy_level: { input: any; output: any };
  referral_status: { input: any; output: any };
  scrape_frequency: { input: any; output: any };
  smallint: { input: any; output: any };
  timestamp: { input: any; output: any };
  timestamptz: { input: any; output: any };
  uuid: { input: any; output: any };
  vector: { input: any; output: any };
};

/** Boolean expression to compare columns of type "Boolean". All fields are combined with logical 'AND'. */
export type BooleanComparisonExp = {
  _eq?: InputMaybe<Scalars["Boolean"]["input"]>;
  _gt?: InputMaybe<Scalars["Boolean"]["input"]>;
  _gte?: InputMaybe<Scalars["Boolean"]["input"]>;
  _in?: InputMaybe<Array<Scalars["Boolean"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lte?: InputMaybe<Scalars["Boolean"]["input"]>;
  _neq?: InputMaybe<Scalars["Boolean"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["Boolean"]["input"]>>;
};

/** Boolean expression to compare columns of type "Int". All fields are combined with logical 'AND'. */
export type IntComparisonExp = {
  _eq?: InputMaybe<Scalars["Int"]["input"]>;
  _gt?: InputMaybe<Scalars["Int"]["input"]>;
  _gte?: InputMaybe<Scalars["Int"]["input"]>;
  _in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["Int"]["input"]>;
  _lte?: InputMaybe<Scalars["Int"]["input"]>;
  _neq?: InputMaybe<Scalars["Int"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["Int"]["input"]>>;
};

/** Boolean expression to compare columns of type "String". All fields are combined with logical 'AND'. */
export type StringArrayComparisonExp = {
  /** is the array contained in the given array value */
  _contained_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
  /** does the array contain the given value */
  _contains?: InputMaybe<Array<Scalars["String"]["input"]>>;
  _eq?: InputMaybe<Array<Scalars["String"]["input"]>>;
  _gt?: InputMaybe<Array<Scalars["String"]["input"]>>;
  _gte?: InputMaybe<Array<Scalars["String"]["input"]>>;
  _in?: InputMaybe<Array<Array<Scalars["String"]["input"]>>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Array<Scalars["String"]["input"]>>;
  _lte?: InputMaybe<Array<Scalars["String"]["input"]>>;
  _neq?: InputMaybe<Array<Scalars["String"]["input"]>>;
  _nin?: InputMaybe<Array<Array<Scalars["String"]["input"]>>>;
};

/** Boolean expression to compare columns of type "String". All fields are combined with logical 'AND'. */
export type StringComparisonExp = {
  _eq?: InputMaybe<Scalars["String"]["input"]>;
  _gt?: InputMaybe<Scalars["String"]["input"]>;
  _gte?: InputMaybe<Scalars["String"]["input"]>;
  /** does the column match the given case-insensitive pattern */
  _ilike?: InputMaybe<Scalars["String"]["input"]>;
  _in?: InputMaybe<Array<Scalars["String"]["input"]>>;
  /** does the column match the given POSIX regular expression, case insensitive */
  _iregex?: InputMaybe<Scalars["String"]["input"]>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  /** does the column match the given pattern */
  _like?: InputMaybe<Scalars["String"]["input"]>;
  _lt?: InputMaybe<Scalars["String"]["input"]>;
  _lte?: InputMaybe<Scalars["String"]["input"]>;
  _neq?: InputMaybe<Scalars["String"]["input"]>;
  /** does the column NOT match the given case-insensitive pattern */
  _nilike?: InputMaybe<Scalars["String"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["String"]["input"]>>;
  /** does the column NOT match the given POSIX regular expression, case insensitive */
  _niregex?: InputMaybe<Scalars["String"]["input"]>;
  /** does the column NOT match the given pattern */
  _nlike?: InputMaybe<Scalars["String"]["input"]>;
  /** does the column NOT match the given POSIX regular expression, case sensitive */
  _nregex?: InputMaybe<Scalars["String"]["input"]>;
  /** does the column NOT match the given SQL regular expression */
  _nsimilar?: InputMaybe<Scalars["String"]["input"]>;
  /** does the column match the given POSIX regular expression, case sensitive */
  _regex?: InputMaybe<Scalars["String"]["input"]>;
  /** does the column match the given SQL regular expression */
  _similar?: InputMaybe<Scalars["String"]["input"]>;
};

/** Boolean expression to compare columns of type "access_level". All fields are combined with logical 'AND'. */
export type AccessLevelComparisonExp = {
  _eq?: InputMaybe<Scalars["access_level"]["input"]>;
  _gt?: InputMaybe<Scalars["access_level"]["input"]>;
  _gte?: InputMaybe<Scalars["access_level"]["input"]>;
  _in?: InputMaybe<Array<Scalars["access_level"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["access_level"]["input"]>;
  _lte?: InputMaybe<Scalars["access_level"]["input"]>;
  _neq?: InputMaybe<Scalars["access_level"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["access_level"]["input"]>>;
};

/** columns and relationships of "ad_daily_metrics" */
export type AdDailyMetrics = {
  __typename?: "ad_daily_metrics";
  /** An object relationship */
  ad_variant?: Maybe<AdVariants>;
  clicks?: Maybe<Scalars["Int"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  date: Scalars["date"]["output"];
  id: Scalars["uuid"]["output"];
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  variant_id?: Maybe<Scalars["uuid"]["output"]>;
  views?: Maybe<Scalars["Int"]["output"]>;
};

/** aggregated selection of "ad_daily_metrics" */
export type AdDailyMetricsAggregate = {
  __typename?: "ad_daily_metrics_aggregate";
  aggregate?: Maybe<AdDailyMetricsAggregateFields>;
  nodes: Array<AdDailyMetrics>;
};

export type AdDailyMetricsAggregateBoolExp = {
  count?: InputMaybe<AdDailyMetricsAggregateBoolExpCount>;
};

export type AdDailyMetricsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<AdDailyMetricsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<AdDailyMetricsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "ad_daily_metrics" */
export type AdDailyMetricsAggregateFields = {
  __typename?: "ad_daily_metrics_aggregate_fields";
  avg?: Maybe<AdDailyMetricsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<AdDailyMetricsMaxFields>;
  min?: Maybe<AdDailyMetricsMinFields>;
  stddev?: Maybe<AdDailyMetricsStddevFields>;
  stddev_pop?: Maybe<AdDailyMetricsStddevPopFields>;
  stddev_samp?: Maybe<AdDailyMetricsStddevSampFields>;
  sum?: Maybe<AdDailyMetricsSumFields>;
  var_pop?: Maybe<AdDailyMetricsVarPopFields>;
  var_samp?: Maybe<AdDailyMetricsVarSampFields>;
  variance?: Maybe<AdDailyMetricsVarianceFields>;
};

/** aggregate fields of "ad_daily_metrics" */
export type AdDailyMetricsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<AdDailyMetricsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "ad_daily_metrics" */
export type AdDailyMetricsAggregateOrderBy = {
  avg?: InputMaybe<AdDailyMetricsAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<AdDailyMetricsMaxOrderBy>;
  min?: InputMaybe<AdDailyMetricsMinOrderBy>;
  stddev?: InputMaybe<AdDailyMetricsStddevOrderBy>;
  stddev_pop?: InputMaybe<AdDailyMetricsStddevPopOrderBy>;
  stddev_samp?: InputMaybe<AdDailyMetricsStddevSampOrderBy>;
  sum?: InputMaybe<AdDailyMetricsSumOrderBy>;
  var_pop?: InputMaybe<AdDailyMetricsVarPopOrderBy>;
  var_samp?: InputMaybe<AdDailyMetricsVarSampOrderBy>;
  variance?: InputMaybe<AdDailyMetricsVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "ad_daily_metrics" */
export type AdDailyMetricsArrRelInsertInput = {
  data: Array<AdDailyMetricsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<AdDailyMetricsOnConflict>;
};

/** aggregate avg on columns */
export type AdDailyMetricsAvgFields = {
  __typename?: "ad_daily_metrics_avg_fields";
  clicks?: Maybe<Scalars["Float"]["output"]>;
  views?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "ad_daily_metrics" */
export type AdDailyMetricsAvgOrderBy = {
  clicks?: InputMaybe<OrderBy>;
  views?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "ad_daily_metrics". All fields are combined with a logical 'AND'. */
export type AdDailyMetricsBoolExp = {
  _and?: InputMaybe<Array<AdDailyMetricsBoolExp>>;
  _not?: InputMaybe<AdDailyMetricsBoolExp>;
  _or?: InputMaybe<Array<AdDailyMetricsBoolExp>>;
  ad_variant?: InputMaybe<AdVariantsBoolExp>;
  clicks?: InputMaybe<IntComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  date?: InputMaybe<DateComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  variant_id?: InputMaybe<UuidComparisonExp>;
  views?: InputMaybe<IntComparisonExp>;
};

/** unique or primary key constraints on table "ad_daily_metrics" */
export enum AdDailyMetricsConstraint {
  /** unique or primary key constraint on columns "id" */
  AD_DAILY_METRICS_PKEY = "ad_daily_metrics_pkey",
  /** unique or primary key constraint on columns "variant_id", "date" */
  AD_DAILY_METRICS_VARIANT_ID_DATE_KEY = "ad_daily_metrics_variant_id_date_key",
}

/** input type for incrementing numeric columns in table "ad_daily_metrics" */
export type AdDailyMetricsIncInput = {
  clicks?: InputMaybe<Scalars["Int"]["input"]>;
  views?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "ad_daily_metrics" */
export type AdDailyMetricsInsertInput = {
  ad_variant?: InputMaybe<AdVariantsObjRelInsertInput>;
  clicks?: InputMaybe<Scalars["Int"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  date?: InputMaybe<Scalars["date"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  variant_id?: InputMaybe<Scalars["uuid"]["input"]>;
  views?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate max on columns */
export type AdDailyMetricsMaxFields = {
  __typename?: "ad_daily_metrics_max_fields";
  clicks?: Maybe<Scalars["Int"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  date?: Maybe<Scalars["date"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  variant_id?: Maybe<Scalars["uuid"]["output"]>;
  views?: Maybe<Scalars["Int"]["output"]>;
};

/** order by max() on columns of table "ad_daily_metrics" */
export type AdDailyMetricsMaxOrderBy = {
  clicks?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  date?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  variant_id?: InputMaybe<OrderBy>;
  views?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type AdDailyMetricsMinFields = {
  __typename?: "ad_daily_metrics_min_fields";
  clicks?: Maybe<Scalars["Int"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  date?: Maybe<Scalars["date"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  variant_id?: Maybe<Scalars["uuid"]["output"]>;
  views?: Maybe<Scalars["Int"]["output"]>;
};

/** order by min() on columns of table "ad_daily_metrics" */
export type AdDailyMetricsMinOrderBy = {
  clicks?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  date?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  variant_id?: InputMaybe<OrderBy>;
  views?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "ad_daily_metrics" */
export type AdDailyMetricsMutationResponse = {
  __typename?: "ad_daily_metrics_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<AdDailyMetrics>;
};

/** on_conflict condition type for table "ad_daily_metrics" */
export type AdDailyMetricsOnConflict = {
  constraint: AdDailyMetricsConstraint;
  update_columns?: Array<AdDailyMetricsUpdateColumn>;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
};

/** Ordering options when selecting data from "ad_daily_metrics". */
export type AdDailyMetricsOrderBy = {
  ad_variant?: InputMaybe<AdVariantsOrderBy>;
  clicks?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  date?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  variant_id?: InputMaybe<OrderBy>;
  views?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: ad_daily_metrics */
export type AdDailyMetricsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "ad_daily_metrics" */
export enum AdDailyMetricsSelectColumn {
  /** column name */
  CLICKS = "clicks",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DATE = "date",
  /** column name */
  ID = "id",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  VARIANT_ID = "variant_id",
  /** column name */
  VIEWS = "views",
}

/** input type for updating data in table "ad_daily_metrics" */
export type AdDailyMetricsSetInput = {
  clicks?: InputMaybe<Scalars["Int"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  date?: InputMaybe<Scalars["date"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  variant_id?: InputMaybe<Scalars["uuid"]["input"]>;
  views?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate stddev on columns */
export type AdDailyMetricsStddevFields = {
  __typename?: "ad_daily_metrics_stddev_fields";
  clicks?: Maybe<Scalars["Float"]["output"]>;
  views?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "ad_daily_metrics" */
export type AdDailyMetricsStddevOrderBy = {
  clicks?: InputMaybe<OrderBy>;
  views?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type AdDailyMetricsStddevPopFields = {
  __typename?: "ad_daily_metrics_stddev_pop_fields";
  clicks?: Maybe<Scalars["Float"]["output"]>;
  views?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "ad_daily_metrics" */
export type AdDailyMetricsStddevPopOrderBy = {
  clicks?: InputMaybe<OrderBy>;
  views?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type AdDailyMetricsStddevSampFields = {
  __typename?: "ad_daily_metrics_stddev_samp_fields";
  clicks?: Maybe<Scalars["Float"]["output"]>;
  views?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "ad_daily_metrics" */
export type AdDailyMetricsStddevSampOrderBy = {
  clicks?: InputMaybe<OrderBy>;
  views?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "ad_daily_metrics" */
export type AdDailyMetricsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: AdDailyMetricsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type AdDailyMetricsStreamCursorValueInput = {
  clicks?: InputMaybe<Scalars["Int"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  date?: InputMaybe<Scalars["date"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  variant_id?: InputMaybe<Scalars["uuid"]["input"]>;
  views?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate sum on columns */
export type AdDailyMetricsSumFields = {
  __typename?: "ad_daily_metrics_sum_fields";
  clicks?: Maybe<Scalars["Int"]["output"]>;
  views?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "ad_daily_metrics" */
export type AdDailyMetricsSumOrderBy = {
  clicks?: InputMaybe<OrderBy>;
  views?: InputMaybe<OrderBy>;
};

/** update columns of table "ad_daily_metrics" */
export enum AdDailyMetricsUpdateColumn {
  /** column name */
  CLICKS = "clicks",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DATE = "date",
  /** column name */
  ID = "id",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  VARIANT_ID = "variant_id",
  /** column name */
  VIEWS = "views",
}

export type AdDailyMetricsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<AdDailyMetricsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<AdDailyMetricsSetInput>;
  /** filter the rows which have to be updated */
  where: AdDailyMetricsBoolExp;
};

/** aggregate var_pop on columns */
export type AdDailyMetricsVarPopFields = {
  __typename?: "ad_daily_metrics_var_pop_fields";
  clicks?: Maybe<Scalars["Float"]["output"]>;
  views?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "ad_daily_metrics" */
export type AdDailyMetricsVarPopOrderBy = {
  clicks?: InputMaybe<OrderBy>;
  views?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type AdDailyMetricsVarSampFields = {
  __typename?: "ad_daily_metrics_var_samp_fields";
  clicks?: Maybe<Scalars["Float"]["output"]>;
  views?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "ad_daily_metrics" */
export type AdDailyMetricsVarSampOrderBy = {
  clicks?: InputMaybe<OrderBy>;
  views?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type AdDailyMetricsVarianceFields = {
  __typename?: "ad_daily_metrics_variance_fields";
  clicks?: Maybe<Scalars["Float"]["output"]>;
  views?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "ad_daily_metrics" */
export type AdDailyMetricsVarianceOrderBy = {
  clicks?: InputMaybe<OrderBy>;
  views?: InputMaybe<OrderBy>;
};

/** columns and relationships of "ad_packages" */
export type AdPackages = {
  __typename?: "ad_packages";
  active?: Maybe<Scalars["Boolean"]["output"]>;
  /** An array relationship */
  ads: Array<Ads>;
  /** An aggregate relationship */
  ads_aggregate: AdsAggregate;
  avg_roi?: Maybe<Scalars["numeric"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description: Scalars["String"]["output"];
  expected_ctr?: Maybe<Scalars["numeric"]["output"]>;
  features: Array<Scalars["String"]["output"]>;
  id: Scalars["uuid"]["output"];
  name: Scalars["String"]["output"];
  position: Scalars["String"]["output"];
  price: Scalars["numeric"]["output"];
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  view_frequency?: Maybe<Scalars["numeric"]["output"]>;
};

/** columns and relationships of "ad_packages" */
export type AdPackagesAdsArgs = {
  distinct_on?: InputMaybe<Array<AdsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdsOrderBy>>;
  where?: InputMaybe<AdsBoolExp>;
};

/** columns and relationships of "ad_packages" */
export type AdPackagesAdsAggregateArgs = {
  distinct_on?: InputMaybe<Array<AdsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdsOrderBy>>;
  where?: InputMaybe<AdsBoolExp>;
};

/** aggregated selection of "ad_packages" */
export type AdPackagesAggregate = {
  __typename?: "ad_packages_aggregate";
  aggregate?: Maybe<AdPackagesAggregateFields>;
  nodes: Array<AdPackages>;
};

/** aggregate fields of "ad_packages" */
export type AdPackagesAggregateFields = {
  __typename?: "ad_packages_aggregate_fields";
  avg?: Maybe<AdPackagesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<AdPackagesMaxFields>;
  min?: Maybe<AdPackagesMinFields>;
  stddev?: Maybe<AdPackagesStddevFields>;
  stddev_pop?: Maybe<AdPackagesStddevPopFields>;
  stddev_samp?: Maybe<AdPackagesStddevSampFields>;
  sum?: Maybe<AdPackagesSumFields>;
  var_pop?: Maybe<AdPackagesVarPopFields>;
  var_samp?: Maybe<AdPackagesVarSampFields>;
  variance?: Maybe<AdPackagesVarianceFields>;
};

/** aggregate fields of "ad_packages" */
export type AdPackagesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<AdPackagesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type AdPackagesAvgFields = {
  __typename?: "ad_packages_avg_fields";
  avg_roi?: Maybe<Scalars["Float"]["output"]>;
  expected_ctr?: Maybe<Scalars["Float"]["output"]>;
  price?: Maybe<Scalars["Float"]["output"]>;
  view_frequency?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "ad_packages". All fields are combined with a logical 'AND'. */
export type AdPackagesBoolExp = {
  _and?: InputMaybe<Array<AdPackagesBoolExp>>;
  _not?: InputMaybe<AdPackagesBoolExp>;
  _or?: InputMaybe<Array<AdPackagesBoolExp>>;
  active?: InputMaybe<BooleanComparisonExp>;
  ads?: InputMaybe<AdsBoolExp>;
  ads_aggregate?: InputMaybe<AdsAggregateBoolExp>;
  avg_roi?: InputMaybe<NumericComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  description?: InputMaybe<StringComparisonExp>;
  expected_ctr?: InputMaybe<NumericComparisonExp>;
  features?: InputMaybe<StringArrayComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  position?: InputMaybe<StringComparisonExp>;
  price?: InputMaybe<NumericComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  view_frequency?: InputMaybe<NumericComparisonExp>;
};

/** unique or primary key constraints on table "ad_packages" */
export enum AdPackagesConstraint {
  /** unique or primary key constraint on columns "id" */
  AD_PACKAGES_PKEY = "ad_packages_pkey",
}

/** input type for incrementing numeric columns in table "ad_packages" */
export type AdPackagesIncInput = {
  avg_roi?: InputMaybe<Scalars["numeric"]["input"]>;
  expected_ctr?: InputMaybe<Scalars["numeric"]["input"]>;
  price?: InputMaybe<Scalars["numeric"]["input"]>;
  view_frequency?: InputMaybe<Scalars["numeric"]["input"]>;
};

/** input type for inserting data into table "ad_packages" */
export type AdPackagesInsertInput = {
  active?: InputMaybe<Scalars["Boolean"]["input"]>;
  ads?: InputMaybe<AdsArrRelInsertInput>;
  avg_roi?: InputMaybe<Scalars["numeric"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  expected_ctr?: InputMaybe<Scalars["numeric"]["input"]>;
  features?: InputMaybe<Array<Scalars["String"]["input"]>>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  position?: InputMaybe<Scalars["String"]["input"]>;
  price?: InputMaybe<Scalars["numeric"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  view_frequency?: InputMaybe<Scalars["numeric"]["input"]>;
};

/** aggregate max on columns */
export type AdPackagesMaxFields = {
  __typename?: "ad_packages_max_fields";
  avg_roi?: Maybe<Scalars["numeric"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  expected_ctr?: Maybe<Scalars["numeric"]["output"]>;
  features?: Maybe<Array<Scalars["String"]["output"]>>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  position?: Maybe<Scalars["String"]["output"]>;
  price?: Maybe<Scalars["numeric"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  view_frequency?: Maybe<Scalars["numeric"]["output"]>;
};

/** aggregate min on columns */
export type AdPackagesMinFields = {
  __typename?: "ad_packages_min_fields";
  avg_roi?: Maybe<Scalars["numeric"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  expected_ctr?: Maybe<Scalars["numeric"]["output"]>;
  features?: Maybe<Array<Scalars["String"]["output"]>>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  position?: Maybe<Scalars["String"]["output"]>;
  price?: Maybe<Scalars["numeric"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  view_frequency?: Maybe<Scalars["numeric"]["output"]>;
};

/** response of any mutation on the table "ad_packages" */
export type AdPackagesMutationResponse = {
  __typename?: "ad_packages_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<AdPackages>;
};

/** input type for inserting object relation for remote table "ad_packages" */
export type AdPackagesObjRelInsertInput = {
  data: AdPackagesInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<AdPackagesOnConflict>;
};

/** on_conflict condition type for table "ad_packages" */
export type AdPackagesOnConflict = {
  constraint: AdPackagesConstraint;
  update_columns?: Array<AdPackagesUpdateColumn>;
  where?: InputMaybe<AdPackagesBoolExp>;
};

/** Ordering options when selecting data from "ad_packages". */
export type AdPackagesOrderBy = {
  active?: InputMaybe<OrderBy>;
  ads_aggregate?: InputMaybe<AdsAggregateOrderBy>;
  avg_roi?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  description?: InputMaybe<OrderBy>;
  expected_ctr?: InputMaybe<OrderBy>;
  features?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  position?: InputMaybe<OrderBy>;
  price?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  view_frequency?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: ad_packages */
export type AdPackagesPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "ad_packages" */
export enum AdPackagesSelectColumn {
  /** column name */
  ACTIVE = "active",
  /** column name */
  AVG_ROI = "avg_roi",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  EXPECTED_CTR = "expected_ctr",
  /** column name */
  FEATURES = "features",
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
  /** column name */
  POSITION = "position",
  /** column name */
  PRICE = "price",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  VIEW_FREQUENCY = "view_frequency",
}

/** input type for updating data in table "ad_packages" */
export type AdPackagesSetInput = {
  active?: InputMaybe<Scalars["Boolean"]["input"]>;
  avg_roi?: InputMaybe<Scalars["numeric"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  expected_ctr?: InputMaybe<Scalars["numeric"]["input"]>;
  features?: InputMaybe<Array<Scalars["String"]["input"]>>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  position?: InputMaybe<Scalars["String"]["input"]>;
  price?: InputMaybe<Scalars["numeric"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  view_frequency?: InputMaybe<Scalars["numeric"]["input"]>;
};

/** aggregate stddev on columns */
export type AdPackagesStddevFields = {
  __typename?: "ad_packages_stddev_fields";
  avg_roi?: Maybe<Scalars["Float"]["output"]>;
  expected_ctr?: Maybe<Scalars["Float"]["output"]>;
  price?: Maybe<Scalars["Float"]["output"]>;
  view_frequency?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type AdPackagesStddevPopFields = {
  __typename?: "ad_packages_stddev_pop_fields";
  avg_roi?: Maybe<Scalars["Float"]["output"]>;
  expected_ctr?: Maybe<Scalars["Float"]["output"]>;
  price?: Maybe<Scalars["Float"]["output"]>;
  view_frequency?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type AdPackagesStddevSampFields = {
  __typename?: "ad_packages_stddev_samp_fields";
  avg_roi?: Maybe<Scalars["Float"]["output"]>;
  expected_ctr?: Maybe<Scalars["Float"]["output"]>;
  price?: Maybe<Scalars["Float"]["output"]>;
  view_frequency?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "ad_packages" */
export type AdPackagesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: AdPackagesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type AdPackagesStreamCursorValueInput = {
  active?: InputMaybe<Scalars["Boolean"]["input"]>;
  avg_roi?: InputMaybe<Scalars["numeric"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  expected_ctr?: InputMaybe<Scalars["numeric"]["input"]>;
  features?: InputMaybe<Array<Scalars["String"]["input"]>>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  position?: InputMaybe<Scalars["String"]["input"]>;
  price?: InputMaybe<Scalars["numeric"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  view_frequency?: InputMaybe<Scalars["numeric"]["input"]>;
};

/** aggregate sum on columns */
export type AdPackagesSumFields = {
  __typename?: "ad_packages_sum_fields";
  avg_roi?: Maybe<Scalars["numeric"]["output"]>;
  expected_ctr?: Maybe<Scalars["numeric"]["output"]>;
  price?: Maybe<Scalars["numeric"]["output"]>;
  view_frequency?: Maybe<Scalars["numeric"]["output"]>;
};

/** update columns of table "ad_packages" */
export enum AdPackagesUpdateColumn {
  /** column name */
  ACTIVE = "active",
  /** column name */
  AVG_ROI = "avg_roi",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  EXPECTED_CTR = "expected_ctr",
  /** column name */
  FEATURES = "features",
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
  /** column name */
  POSITION = "position",
  /** column name */
  PRICE = "price",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  VIEW_FREQUENCY = "view_frequency",
}

export type AdPackagesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<AdPackagesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<AdPackagesSetInput>;
  /** filter the rows which have to be updated */
  where: AdPackagesBoolExp;
};

/** aggregate var_pop on columns */
export type AdPackagesVarPopFields = {
  __typename?: "ad_packages_var_pop_fields";
  avg_roi?: Maybe<Scalars["Float"]["output"]>;
  expected_ctr?: Maybe<Scalars["Float"]["output"]>;
  price?: Maybe<Scalars["Float"]["output"]>;
  view_frequency?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type AdPackagesVarSampFields = {
  __typename?: "ad_packages_var_samp_fields";
  avg_roi?: Maybe<Scalars["Float"]["output"]>;
  expected_ctr?: Maybe<Scalars["Float"]["output"]>;
  price?: Maybe<Scalars["Float"]["output"]>;
  view_frequency?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type AdPackagesVarianceFields = {
  __typename?: "ad_packages_variance_fields";
  avg_roi?: Maybe<Scalars["Float"]["output"]>;
  expected_ctr?: Maybe<Scalars["Float"]["output"]>;
  price?: Maybe<Scalars["Float"]["output"]>;
  view_frequency?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "ad_variants" */
export type AdVariants = {
  __typename?: "ad_variants";
  active?: Maybe<Scalars["Boolean"]["output"]>;
  /** An object relationship */
  ad: Ads;
  /** An array relationship */
  ad_daily_metrics: Array<AdDailyMetrics>;
  /** An aggregate relationship */
  ad_daily_metrics_aggregate: AdDailyMetricsAggregate;
  ad_id: Scalars["uuid"]["output"];
  content: Scalars["jsonb"]["output"];
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id: Scalars["uuid"]["output"];
  is_control?: Maybe<Scalars["Boolean"]["output"]>;
  performance_metrics?: Maybe<Scalars["jsonb"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** columns and relationships of "ad_variants" */
export type AdVariantsAdDailyMetricsArgs = {
  distinct_on?: InputMaybe<Array<AdDailyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdDailyMetricsOrderBy>>;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
};

/** columns and relationships of "ad_variants" */
export type AdVariantsAdDailyMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<AdDailyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdDailyMetricsOrderBy>>;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
};

/** columns and relationships of "ad_variants" */
export type AdVariantsContentArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "ad_variants" */
export type AdVariantsPerformanceMetricsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "ad_variants" */
export type AdVariantsAggregate = {
  __typename?: "ad_variants_aggregate";
  aggregate?: Maybe<AdVariantsAggregateFields>;
  nodes: Array<AdVariants>;
};

export type AdVariantsAggregateBoolExp = {
  bool_and?: InputMaybe<AdVariantsAggregateBoolExpBoolAnd>;
  bool_or?: InputMaybe<AdVariantsAggregateBoolExpBoolOr>;
  count?: InputMaybe<AdVariantsAggregateBoolExpCount>;
};

export type AdVariantsAggregateBoolExpBoolAnd = {
  arguments: AdVariantsSelectColumnAdVariantsAggregateBoolExpBoolAndArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<AdVariantsBoolExp>;
  predicate: BooleanComparisonExp;
};

export type AdVariantsAggregateBoolExpBoolOr = {
  arguments: AdVariantsSelectColumnAdVariantsAggregateBoolExpBoolOrArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<AdVariantsBoolExp>;
  predicate: BooleanComparisonExp;
};

export type AdVariantsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<AdVariantsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<AdVariantsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "ad_variants" */
export type AdVariantsAggregateFields = {
  __typename?: "ad_variants_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<AdVariantsMaxFields>;
  min?: Maybe<AdVariantsMinFields>;
};

/** aggregate fields of "ad_variants" */
export type AdVariantsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<AdVariantsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "ad_variants" */
export type AdVariantsAggregateOrderBy = {
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<AdVariantsMaxOrderBy>;
  min?: InputMaybe<AdVariantsMinOrderBy>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type AdVariantsAppendInput = {
  content?: InputMaybe<Scalars["jsonb"]["input"]>;
  performance_metrics?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** input type for inserting array relation for remote table "ad_variants" */
export type AdVariantsArrRelInsertInput = {
  data: Array<AdVariantsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<AdVariantsOnConflict>;
};

/** Boolean expression to filter rows from the table "ad_variants". All fields are combined with a logical 'AND'. */
export type AdVariantsBoolExp = {
  _and?: InputMaybe<Array<AdVariantsBoolExp>>;
  _not?: InputMaybe<AdVariantsBoolExp>;
  _or?: InputMaybe<Array<AdVariantsBoolExp>>;
  active?: InputMaybe<BooleanComparisonExp>;
  ad?: InputMaybe<AdsBoolExp>;
  ad_daily_metrics?: InputMaybe<AdDailyMetricsBoolExp>;
  ad_daily_metrics_aggregate?: InputMaybe<AdDailyMetricsAggregateBoolExp>;
  ad_id?: InputMaybe<UuidComparisonExp>;
  content?: InputMaybe<JsonbComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  is_control?: InputMaybe<BooleanComparisonExp>;
  performance_metrics?: InputMaybe<JsonbComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
};

/** unique or primary key constraints on table "ad_variants" */
export enum AdVariantsConstraint {
  /** unique or primary key constraint on columns "id" */
  AD_VARIANTS_PKEY = "ad_variants_pkey",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type AdVariantsDeleteAtPathInput = {
  content?: InputMaybe<Array<Scalars["String"]["input"]>>;
  performance_metrics?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type AdVariantsDeleteElemInput = {
  content?: InputMaybe<Scalars["Int"]["input"]>;
  performance_metrics?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type AdVariantsDeleteKeyInput = {
  content?: InputMaybe<Scalars["String"]["input"]>;
  performance_metrics?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for inserting data into table "ad_variants" */
export type AdVariantsInsertInput = {
  active?: InputMaybe<Scalars["Boolean"]["input"]>;
  ad?: InputMaybe<AdsObjRelInsertInput>;
  ad_daily_metrics?: InputMaybe<AdDailyMetricsArrRelInsertInput>;
  ad_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content?: InputMaybe<Scalars["jsonb"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_control?: InputMaybe<Scalars["Boolean"]["input"]>;
  performance_metrics?: InputMaybe<Scalars["jsonb"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate max on columns */
export type AdVariantsMaxFields = {
  __typename?: "ad_variants_max_fields";
  ad_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** order by max() on columns of table "ad_variants" */
export type AdVariantsMaxOrderBy = {
  ad_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type AdVariantsMinFields = {
  __typename?: "ad_variants_min_fields";
  ad_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** order by min() on columns of table "ad_variants" */
export type AdVariantsMinOrderBy = {
  ad_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "ad_variants" */
export type AdVariantsMutationResponse = {
  __typename?: "ad_variants_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<AdVariants>;
};

/** input type for inserting object relation for remote table "ad_variants" */
export type AdVariantsObjRelInsertInput = {
  data: AdVariantsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<AdVariantsOnConflict>;
};

/** on_conflict condition type for table "ad_variants" */
export type AdVariantsOnConflict = {
  constraint: AdVariantsConstraint;
  update_columns?: Array<AdVariantsUpdateColumn>;
  where?: InputMaybe<AdVariantsBoolExp>;
};

/** Ordering options when selecting data from "ad_variants". */
export type AdVariantsOrderBy = {
  active?: InputMaybe<OrderBy>;
  ad?: InputMaybe<AdsOrderBy>;
  ad_daily_metrics_aggregate?: InputMaybe<AdDailyMetricsAggregateOrderBy>;
  ad_id?: InputMaybe<OrderBy>;
  content?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  is_control?: InputMaybe<OrderBy>;
  performance_metrics?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: ad_variants */
export type AdVariantsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type AdVariantsPrependInput = {
  content?: InputMaybe<Scalars["jsonb"]["input"]>;
  performance_metrics?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "ad_variants" */
export enum AdVariantsSelectColumn {
  /** column name */
  ACTIVE = "active",
  /** column name */
  AD_ID = "ad_id",
  /** column name */
  CONTENT = "content",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  IS_CONTROL = "is_control",
  /** column name */
  PERFORMANCE_METRICS = "performance_metrics",
  /** column name */
  UPDATED_AT = "updated_at",
}

/** select "ad_variants_aggregate_bool_exp_bool_and_arguments_columns" columns of table "ad_variants" */
export enum AdVariantsSelectColumnAdVariantsAggregateBoolExpBoolAndArgumentsColumns {
  /** column name */
  ACTIVE = "active",
  /** column name */
  IS_CONTROL = "is_control",
}

/** select "ad_variants_aggregate_bool_exp_bool_or_arguments_columns" columns of table "ad_variants" */
export enum AdVariantsSelectColumnAdVariantsAggregateBoolExpBoolOrArgumentsColumns {
  /** column name */
  ACTIVE = "active",
  /** column name */
  IS_CONTROL = "is_control",
}

/** input type for updating data in table "ad_variants" */
export type AdVariantsSetInput = {
  active?: InputMaybe<Scalars["Boolean"]["input"]>;
  ad_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content?: InputMaybe<Scalars["jsonb"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_control?: InputMaybe<Scalars["Boolean"]["input"]>;
  performance_metrics?: InputMaybe<Scalars["jsonb"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** Streaming cursor of the table "ad_variants" */
export type AdVariantsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: AdVariantsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type AdVariantsStreamCursorValueInput = {
  active?: InputMaybe<Scalars["Boolean"]["input"]>;
  ad_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content?: InputMaybe<Scalars["jsonb"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_control?: InputMaybe<Scalars["Boolean"]["input"]>;
  performance_metrics?: InputMaybe<Scalars["jsonb"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** update columns of table "ad_variants" */
export enum AdVariantsUpdateColumn {
  /** column name */
  ACTIVE = "active",
  /** column name */
  AD_ID = "ad_id",
  /** column name */
  CONTENT = "content",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  IS_CONTROL = "is_control",
  /** column name */
  PERFORMANCE_METRICS = "performance_metrics",
  /** column name */
  UPDATED_AT = "updated_at",
}

export type AdVariantsUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<AdVariantsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<AdVariantsDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<AdVariantsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<AdVariantsDeleteKeyInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<AdVariantsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<AdVariantsSetInput>;
  /** filter the rows which have to be updated */
  where: AdVariantsBoolExp;
};

/** Boolean expression to compare columns of type "address_type". All fields are combined with logical 'AND'. */
export type AddressTypeComparisonExp = {
  _eq?: InputMaybe<Scalars["address_type"]["input"]>;
  _gt?: InputMaybe<Scalars["address_type"]["input"]>;
  _gte?: InputMaybe<Scalars["address_type"]["input"]>;
  _in?: InputMaybe<Array<Scalars["address_type"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["address_type"]["input"]>;
  _lte?: InputMaybe<Scalars["address_type"]["input"]>;
  _neq?: InputMaybe<Scalars["address_type"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["address_type"]["input"]>>;
};

/** columns and relationships of "addresses" */
export type Addresses = {
  __typename?: "addresses";
  address_type?: Maybe<Scalars["address_type"]["output"]>;
  /** An object relationship */
  city: Cities;
  city_id: Scalars["Int"]["output"];
  /** An object relationship */
  company?: Maybe<Companies>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  /** An object relationship */
  country: Countries;
  country_id: Scalars["Int"]["output"];
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id: Scalars["Int"]["output"];
  is_primary?: Maybe<Scalars["Boolean"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  street1: Scalars["String"]["output"];
  street2?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
  /** An object relationship */
  user_profile?: Maybe<UserProfiles>;
};

/** aggregated selection of "addresses" */
export type AddressesAggregate = {
  __typename?: "addresses_aggregate";
  aggregate?: Maybe<AddressesAggregateFields>;
  nodes: Array<Addresses>;
};

export type AddressesAggregateBoolExp = {
  bool_and?: InputMaybe<AddressesAggregateBoolExpBoolAnd>;
  bool_or?: InputMaybe<AddressesAggregateBoolExpBoolOr>;
  count?: InputMaybe<AddressesAggregateBoolExpCount>;
};

export type AddressesAggregateBoolExpBoolAnd = {
  arguments: AddressesSelectColumnAddressesAggregateBoolExpBoolAndArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<AddressesBoolExp>;
  predicate: BooleanComparisonExp;
};

export type AddressesAggregateBoolExpBoolOr = {
  arguments: AddressesSelectColumnAddressesAggregateBoolExpBoolOrArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<AddressesBoolExp>;
  predicate: BooleanComparisonExp;
};

export type AddressesAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<AddressesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<AddressesBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "addresses" */
export type AddressesAggregateFields = {
  __typename?: "addresses_aggregate_fields";
  avg?: Maybe<AddressesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<AddressesMaxFields>;
  min?: Maybe<AddressesMinFields>;
  stddev?: Maybe<AddressesStddevFields>;
  stddev_pop?: Maybe<AddressesStddevPopFields>;
  stddev_samp?: Maybe<AddressesStddevSampFields>;
  sum?: Maybe<AddressesSumFields>;
  var_pop?: Maybe<AddressesVarPopFields>;
  var_samp?: Maybe<AddressesVarSampFields>;
  variance?: Maybe<AddressesVarianceFields>;
};

/** aggregate fields of "addresses" */
export type AddressesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<AddressesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "addresses" */
export type AddressesAggregateOrderBy = {
  avg?: InputMaybe<AddressesAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<AddressesMaxOrderBy>;
  min?: InputMaybe<AddressesMinOrderBy>;
  stddev?: InputMaybe<AddressesStddevOrderBy>;
  stddev_pop?: InputMaybe<AddressesStddevPopOrderBy>;
  stddev_samp?: InputMaybe<AddressesStddevSampOrderBy>;
  sum?: InputMaybe<AddressesSumOrderBy>;
  var_pop?: InputMaybe<AddressesVarPopOrderBy>;
  var_samp?: InputMaybe<AddressesVarSampOrderBy>;
  variance?: InputMaybe<AddressesVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "addresses" */
export type AddressesArrRelInsertInput = {
  data: Array<AddressesInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<AddressesOnConflict>;
};

/** aggregate avg on columns */
export type AddressesAvgFields = {
  __typename?: "addresses_avg_fields";
  city_id?: Maybe<Scalars["Float"]["output"]>;
  country_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "addresses" */
export type AddressesAvgOrderBy = {
  city_id?: InputMaybe<OrderBy>;
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "addresses". All fields are combined with a logical 'AND'. */
export type AddressesBoolExp = {
  _and?: InputMaybe<Array<AddressesBoolExp>>;
  _not?: InputMaybe<AddressesBoolExp>;
  _or?: InputMaybe<Array<AddressesBoolExp>>;
  address_type?: InputMaybe<AddressTypeComparisonExp>;
  city?: InputMaybe<CitiesBoolExp>;
  city_id?: InputMaybe<IntComparisonExp>;
  company?: InputMaybe<CompaniesBoolExp>;
  company_id?: InputMaybe<UuidComparisonExp>;
  country?: InputMaybe<CountriesBoolExp>;
  country_id?: InputMaybe<IntComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  is_primary?: InputMaybe<BooleanComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  street1?: InputMaybe<StringComparisonExp>;
  street2?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
  user_profile?: InputMaybe<UserProfilesBoolExp>;
};

/** unique or primary key constraints on table "addresses" */
export enum AddressesConstraint {
  /** unique or primary key constraint on columns "id" */
  ADDRESSES_PKEY = "addresses_pkey",
}

/** input type for incrementing numeric columns in table "addresses" */
export type AddressesIncInput = {
  city_id?: InputMaybe<Scalars["Int"]["input"]>;
  country_id?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "addresses" */
export type AddressesInsertInput = {
  address_type?: InputMaybe<Scalars["address_type"]["input"]>;
  city?: InputMaybe<CitiesObjRelInsertInput>;
  city_id?: InputMaybe<Scalars["Int"]["input"]>;
  company?: InputMaybe<CompaniesObjRelInsertInput>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  country?: InputMaybe<CountriesObjRelInsertInput>;
  country_id?: InputMaybe<Scalars["Int"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  street1?: InputMaybe<Scalars["String"]["input"]>;
  street2?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
};

/** aggregate max on columns */
export type AddressesMaxFields = {
  __typename?: "addresses_max_fields";
  address_type?: Maybe<Scalars["address_type"]["output"]>;
  city_id?: Maybe<Scalars["Int"]["output"]>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  country_id?: Maybe<Scalars["Int"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  street1?: Maybe<Scalars["String"]["output"]>;
  street2?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by max() on columns of table "addresses" */
export type AddressesMaxOrderBy = {
  address_type?: InputMaybe<OrderBy>;
  city_id?: InputMaybe<OrderBy>;
  company_id?: InputMaybe<OrderBy>;
  country_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  street1?: InputMaybe<OrderBy>;
  street2?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type AddressesMinFields = {
  __typename?: "addresses_min_fields";
  address_type?: Maybe<Scalars["address_type"]["output"]>;
  city_id?: Maybe<Scalars["Int"]["output"]>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  country_id?: Maybe<Scalars["Int"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  street1?: Maybe<Scalars["String"]["output"]>;
  street2?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by min() on columns of table "addresses" */
export type AddressesMinOrderBy = {
  address_type?: InputMaybe<OrderBy>;
  city_id?: InputMaybe<OrderBy>;
  company_id?: InputMaybe<OrderBy>;
  country_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  street1?: InputMaybe<OrderBy>;
  street2?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "addresses" */
export type AddressesMutationResponse = {
  __typename?: "addresses_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Addresses>;
};

/** on_conflict condition type for table "addresses" */
export type AddressesOnConflict = {
  constraint: AddressesConstraint;
  update_columns?: Array<AddressesUpdateColumn>;
  where?: InputMaybe<AddressesBoolExp>;
};

/** Ordering options when selecting data from "addresses". */
export type AddressesOrderBy = {
  address_type?: InputMaybe<OrderBy>;
  city?: InputMaybe<CitiesOrderBy>;
  city_id?: InputMaybe<OrderBy>;
  company?: InputMaybe<CompaniesOrderBy>;
  company_id?: InputMaybe<OrderBy>;
  country?: InputMaybe<CountriesOrderBy>;
  country_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  is_primary?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  street1?: InputMaybe<OrderBy>;
  street2?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  user_profile?: InputMaybe<UserProfilesOrderBy>;
};

/** primary key columns input for table: addresses */
export type AddressesPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "addresses" */
export enum AddressesSelectColumn {
  /** column name */
  ADDRESS_TYPE = "address_type",
  /** column name */
  CITY_ID = "city_id",
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  COUNTRY_ID = "country_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  IS_PRIMARY = "is_primary",
  /** column name */
  NAME = "name",
  /** column name */
  STREET1 = "street1",
  /** column name */
  STREET2 = "street2",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

/** select "addresses_aggregate_bool_exp_bool_and_arguments_columns" columns of table "addresses" */
export enum AddressesSelectColumnAddressesAggregateBoolExpBoolAndArgumentsColumns {
  /** column name */
  IS_PRIMARY = "is_primary",
}

/** select "addresses_aggregate_bool_exp_bool_or_arguments_columns" columns of table "addresses" */
export enum AddressesSelectColumnAddressesAggregateBoolExpBoolOrArgumentsColumns {
  /** column name */
  IS_PRIMARY = "is_primary",
}

/** input type for updating data in table "addresses" */
export type AddressesSetInput = {
  address_type?: InputMaybe<Scalars["address_type"]["input"]>;
  city_id?: InputMaybe<Scalars["Int"]["input"]>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  country_id?: InputMaybe<Scalars["Int"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  street1?: InputMaybe<Scalars["String"]["input"]>;
  street2?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate stddev on columns */
export type AddressesStddevFields = {
  __typename?: "addresses_stddev_fields";
  city_id?: Maybe<Scalars["Float"]["output"]>;
  country_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "addresses" */
export type AddressesStddevOrderBy = {
  city_id?: InputMaybe<OrderBy>;
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type AddressesStddevPopFields = {
  __typename?: "addresses_stddev_pop_fields";
  city_id?: Maybe<Scalars["Float"]["output"]>;
  country_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "addresses" */
export type AddressesStddevPopOrderBy = {
  city_id?: InputMaybe<OrderBy>;
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type AddressesStddevSampFields = {
  __typename?: "addresses_stddev_samp_fields";
  city_id?: Maybe<Scalars["Float"]["output"]>;
  country_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "addresses" */
export type AddressesStddevSampOrderBy = {
  city_id?: InputMaybe<OrderBy>;
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "addresses" */
export type AddressesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: AddressesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type AddressesStreamCursorValueInput = {
  address_type?: InputMaybe<Scalars["address_type"]["input"]>;
  city_id?: InputMaybe<Scalars["Int"]["input"]>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  country_id?: InputMaybe<Scalars["Int"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  street1?: InputMaybe<Scalars["String"]["input"]>;
  street2?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate sum on columns */
export type AddressesSumFields = {
  __typename?: "addresses_sum_fields";
  city_id?: Maybe<Scalars["Int"]["output"]>;
  country_id?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "addresses" */
export type AddressesSumOrderBy = {
  city_id?: InputMaybe<OrderBy>;
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** update columns of table "addresses" */
export enum AddressesUpdateColumn {
  /** column name */
  ADDRESS_TYPE = "address_type",
  /** column name */
  CITY_ID = "city_id",
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  COUNTRY_ID = "country_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  IS_PRIMARY = "is_primary",
  /** column name */
  NAME = "name",
  /** column name */
  STREET1 = "street1",
  /** column name */
  STREET2 = "street2",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

export type AddressesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<AddressesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<AddressesSetInput>;
  /** filter the rows which have to be updated */
  where: AddressesBoolExp;
};

/** aggregate var_pop on columns */
export type AddressesVarPopFields = {
  __typename?: "addresses_var_pop_fields";
  city_id?: Maybe<Scalars["Float"]["output"]>;
  country_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "addresses" */
export type AddressesVarPopOrderBy = {
  city_id?: InputMaybe<OrderBy>;
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type AddressesVarSampFields = {
  __typename?: "addresses_var_samp_fields";
  city_id?: Maybe<Scalars["Float"]["output"]>;
  country_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "addresses" */
export type AddressesVarSampOrderBy = {
  city_id?: InputMaybe<OrderBy>;
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type AddressesVarianceFields = {
  __typename?: "addresses_variance_fields";
  city_id?: Maybe<Scalars["Float"]["output"]>;
  country_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "addresses" */
export type AddressesVarianceOrderBy = {
  city_id?: InputMaybe<OrderBy>;
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** columns and relationships of "ads" */
export type Ads = {
  __typename?: "ads";
  active?: Maybe<Scalars["Boolean"]["output"]>;
  /** An object relationship */
  ad_package?: Maybe<AdPackages>;
  /** An array relationship */
  ad_variants: Array<AdVariants>;
  /** An aggregate relationship */
  ad_variants_aggregate: AdVariantsAggregate;
  /** An object relationship */
  company?: Maybe<Companies>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  end_date: Scalars["timestamptz"]["output"];
  id: Scalars["uuid"]["output"];
  package_id?: Maybe<Scalars["uuid"]["output"]>;
  start_date: Scalars["timestamptz"]["output"];
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** columns and relationships of "ads" */
export type AdsAdVariantsArgs = {
  distinct_on?: InputMaybe<Array<AdVariantsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdVariantsOrderBy>>;
  where?: InputMaybe<AdVariantsBoolExp>;
};

/** columns and relationships of "ads" */
export type AdsAdVariantsAggregateArgs = {
  distinct_on?: InputMaybe<Array<AdVariantsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdVariantsOrderBy>>;
  where?: InputMaybe<AdVariantsBoolExp>;
};

/** aggregated selection of "ads" */
export type AdsAggregate = {
  __typename?: "ads_aggregate";
  aggregate?: Maybe<AdsAggregateFields>;
  nodes: Array<Ads>;
};

export type AdsAggregateBoolExp = {
  bool_and?: InputMaybe<AdsAggregateBoolExpBoolAnd>;
  bool_or?: InputMaybe<AdsAggregateBoolExpBoolOr>;
  count?: InputMaybe<AdsAggregateBoolExpCount>;
};

export type AdsAggregateBoolExpBoolAnd = {
  arguments: AdsSelectColumnAdsAggregateBoolExpBoolAndArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<AdsBoolExp>;
  predicate: BooleanComparisonExp;
};

export type AdsAggregateBoolExpBoolOr = {
  arguments: AdsSelectColumnAdsAggregateBoolExpBoolOrArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<AdsBoolExp>;
  predicate: BooleanComparisonExp;
};

export type AdsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<AdsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<AdsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "ads" */
export type AdsAggregateFields = {
  __typename?: "ads_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<AdsMaxFields>;
  min?: Maybe<AdsMinFields>;
};

/** aggregate fields of "ads" */
export type AdsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<AdsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "ads" */
export type AdsAggregateOrderBy = {
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<AdsMaxOrderBy>;
  min?: InputMaybe<AdsMinOrderBy>;
};

/** input type for inserting array relation for remote table "ads" */
export type AdsArrRelInsertInput = {
  data: Array<AdsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<AdsOnConflict>;
};

/** Boolean expression to filter rows from the table "ads". All fields are combined with a logical 'AND'. */
export type AdsBoolExp = {
  _and?: InputMaybe<Array<AdsBoolExp>>;
  _not?: InputMaybe<AdsBoolExp>;
  _or?: InputMaybe<Array<AdsBoolExp>>;
  active?: InputMaybe<BooleanComparisonExp>;
  ad_package?: InputMaybe<AdPackagesBoolExp>;
  ad_variants?: InputMaybe<AdVariantsBoolExp>;
  ad_variants_aggregate?: InputMaybe<AdVariantsAggregateBoolExp>;
  company?: InputMaybe<CompaniesBoolExp>;
  company_id?: InputMaybe<UuidComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  end_date?: InputMaybe<TimestamptzComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  package_id?: InputMaybe<UuidComparisonExp>;
  start_date?: InputMaybe<TimestamptzComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
};

/** unique or primary key constraints on table "ads" */
export enum AdsConstraint {
  /** unique or primary key constraint on columns "id" */
  ADS_PKEY = "ads_pkey",
}

/** input type for inserting data into table "ads" */
export type AdsInsertInput = {
  active?: InputMaybe<Scalars["Boolean"]["input"]>;
  ad_package?: InputMaybe<AdPackagesObjRelInsertInput>;
  ad_variants?: InputMaybe<AdVariantsArrRelInsertInput>;
  company?: InputMaybe<CompaniesObjRelInsertInput>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  end_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  package_id?: InputMaybe<Scalars["uuid"]["input"]>;
  start_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate max on columns */
export type AdsMaxFields = {
  __typename?: "ads_max_fields";
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  end_date?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  package_id?: Maybe<Scalars["uuid"]["output"]>;
  start_date?: Maybe<Scalars["timestamptz"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** order by max() on columns of table "ads" */
export type AdsMaxOrderBy = {
  company_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  end_date?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  package_id?: InputMaybe<OrderBy>;
  start_date?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type AdsMinFields = {
  __typename?: "ads_min_fields";
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  end_date?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  package_id?: Maybe<Scalars["uuid"]["output"]>;
  start_date?: Maybe<Scalars["timestamptz"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** order by min() on columns of table "ads" */
export type AdsMinOrderBy = {
  company_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  end_date?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  package_id?: InputMaybe<OrderBy>;
  start_date?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "ads" */
export type AdsMutationResponse = {
  __typename?: "ads_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Ads>;
};

/** input type for inserting object relation for remote table "ads" */
export type AdsObjRelInsertInput = {
  data: AdsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<AdsOnConflict>;
};

/** on_conflict condition type for table "ads" */
export type AdsOnConflict = {
  constraint: AdsConstraint;
  update_columns?: Array<AdsUpdateColumn>;
  where?: InputMaybe<AdsBoolExp>;
};

/** Ordering options when selecting data from "ads". */
export type AdsOrderBy = {
  active?: InputMaybe<OrderBy>;
  ad_package?: InputMaybe<AdPackagesOrderBy>;
  ad_variants_aggregate?: InputMaybe<AdVariantsAggregateOrderBy>;
  company?: InputMaybe<CompaniesOrderBy>;
  company_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  end_date?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  package_id?: InputMaybe<OrderBy>;
  start_date?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: ads */
export type AdsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "ads" */
export enum AdsSelectColumn {
  /** column name */
  ACTIVE = "active",
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  END_DATE = "end_date",
  /** column name */
  ID = "id",
  /** column name */
  PACKAGE_ID = "package_id",
  /** column name */
  START_DATE = "start_date",
  /** column name */
  UPDATED_AT = "updated_at",
}

/** select "ads_aggregate_bool_exp_bool_and_arguments_columns" columns of table "ads" */
export enum AdsSelectColumnAdsAggregateBoolExpBoolAndArgumentsColumns {
  /** column name */
  ACTIVE = "active",
}

/** select "ads_aggregate_bool_exp_bool_or_arguments_columns" columns of table "ads" */
export enum AdsSelectColumnAdsAggregateBoolExpBoolOrArgumentsColumns {
  /** column name */
  ACTIVE = "active",
}

/** input type for updating data in table "ads" */
export type AdsSetInput = {
  active?: InputMaybe<Scalars["Boolean"]["input"]>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  end_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  package_id?: InputMaybe<Scalars["uuid"]["input"]>;
  start_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** Streaming cursor of the table "ads" */
export type AdsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: AdsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type AdsStreamCursorValueInput = {
  active?: InputMaybe<Scalars["Boolean"]["input"]>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  end_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  package_id?: InputMaybe<Scalars["uuid"]["input"]>;
  start_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** update columns of table "ads" */
export enum AdsUpdateColumn {
  /** column name */
  ACTIVE = "active",
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  END_DATE = "end_date",
  /** column name */
  ID = "id",
  /** column name */
  PACKAGE_ID = "package_id",
  /** column name */
  START_DATE = "start_date",
  /** column name */
  UPDATED_AT = "updated_at",
}

export type AdsUpdates = {
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<AdsSetInput>;
  /** filter the rows which have to be updated */
  where: AdsBoolExp;
};

/** Boolean expression to compare columns of type "app_plan_enum". All fields are combined with logical 'AND'. */
export type AppPlanEnumComparisonExp = {
  _eq?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
  _gt?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
  _gte?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
  _in?: InputMaybe<Array<Scalars["app_plan_enum"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
  _lte?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
  _neq?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["app_plan_enum"]["input"]>>;
};

/** Boolean expression to compare columns of type "app_role_enum". All fields are combined with logical 'AND'. */
export type AppRoleEnumArrayComparisonExp = {
  /** is the array contained in the given array value */
  _contained_in?: InputMaybe<Array<Scalars["app_role_enum"]["input"]>>;
  /** does the array contain the given value */
  _contains?: InputMaybe<Array<Scalars["app_role_enum"]["input"]>>;
  _eq?: InputMaybe<Array<Scalars["app_role_enum"]["input"]>>;
  _gt?: InputMaybe<Array<Scalars["app_role_enum"]["input"]>>;
  _gte?: InputMaybe<Array<Scalars["app_role_enum"]["input"]>>;
  _in?: InputMaybe<Array<Array<Scalars["app_role_enum"]["input"]>>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Array<Scalars["app_role_enum"]["input"]>>;
  _lte?: InputMaybe<Array<Scalars["app_role_enum"]["input"]>>;
  _neq?: InputMaybe<Array<Scalars["app_role_enum"]["input"]>>;
  _nin?: InputMaybe<Array<Array<Scalars["app_role_enum"]["input"]>>>;
};

/** Boolean expression to compare columns of type "app_role_enum". All fields are combined with logical 'AND'. */
export type AppRoleEnumComparisonExp = {
  _eq?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  _gt?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  _gte?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  _in?: InputMaybe<Array<Scalars["app_role_enum"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  _lte?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  _neq?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["app_role_enum"]["input"]>>;
};

/** Boolean expression to compare columns of type "bigint". All fields are combined with logical 'AND'. */
export type BigintComparisonExp = {
  _eq?: InputMaybe<Scalars["bigint"]["input"]>;
  _gt?: InputMaybe<Scalars["bigint"]["input"]>;
  _gte?: InputMaybe<Scalars["bigint"]["input"]>;
  _in?: InputMaybe<Array<Scalars["bigint"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["bigint"]["input"]>;
  _lte?: InputMaybe<Scalars["bigint"]["input"]>;
  _neq?: InputMaybe<Scalars["bigint"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["bigint"]["input"]>>;
};

/** columns and relationships of "blacklisted_domains" */
export type BlacklistedDomains = {
  __typename?: "blacklisted_domains";
  created_at: Scalars["timestamptz"]["output"];
  id: Scalars["uuid"]["output"];
  reason?: Maybe<Scalars["String"]["output"]>;
  url: Scalars["String"]["output"];
};

/** aggregated selection of "blacklisted_domains" */
export type BlacklistedDomainsAggregate = {
  __typename?: "blacklisted_domains_aggregate";
  aggregate?: Maybe<BlacklistedDomainsAggregateFields>;
  nodes: Array<BlacklistedDomains>;
};

/** aggregate fields of "blacklisted_domains" */
export type BlacklistedDomainsAggregateFields = {
  __typename?: "blacklisted_domains_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<BlacklistedDomainsMaxFields>;
  min?: Maybe<BlacklistedDomainsMinFields>;
};

/** aggregate fields of "blacklisted_domains" */
export type BlacklistedDomainsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<BlacklistedDomainsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** Boolean expression to filter rows from the table "blacklisted_domains". All fields are combined with a logical 'AND'. */
export type BlacklistedDomainsBoolExp = {
  _and?: InputMaybe<Array<BlacklistedDomainsBoolExp>>;
  _not?: InputMaybe<BlacklistedDomainsBoolExp>;
  _or?: InputMaybe<Array<BlacklistedDomainsBoolExp>>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  reason?: InputMaybe<StringComparisonExp>;
  url?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "blacklisted_domains" */
export enum BlacklistedDomainsConstraint {
  /** unique or primary key constraint on columns "id" */
  BLACKLISTED_DOMAINS_PKEY = "blacklisted_domains_pkey",
  /** unique or primary key constraint on columns "url" */
  BLACKLISTED_DOMAINS_URL_KEY = "blacklisted_domains_url_key",
}

/** input type for inserting data into table "blacklisted_domains" */
export type BlacklistedDomainsInsertInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  reason?: InputMaybe<Scalars["String"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type BlacklistedDomainsMaxFields = {
  __typename?: "blacklisted_domains_max_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  reason?: Maybe<Scalars["String"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** aggregate min on columns */
export type BlacklistedDomainsMinFields = {
  __typename?: "blacklisted_domains_min_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  reason?: Maybe<Scalars["String"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** response of any mutation on the table "blacklisted_domains" */
export type BlacklistedDomainsMutationResponse = {
  __typename?: "blacklisted_domains_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<BlacklistedDomains>;
};

/** on_conflict condition type for table "blacklisted_domains" */
export type BlacklistedDomainsOnConflict = {
  constraint: BlacklistedDomainsConstraint;
  update_columns?: Array<BlacklistedDomainsUpdateColumn>;
  where?: InputMaybe<BlacklistedDomainsBoolExp>;
};

/** Ordering options when selecting data from "blacklisted_domains". */
export type BlacklistedDomainsOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  reason?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: blacklisted_domains */
export type BlacklistedDomainsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "blacklisted_domains" */
export enum BlacklistedDomainsSelectColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  REASON = "reason",
  /** column name */
  URL = "url",
}

/** input type for updating data in table "blacklisted_domains" */
export type BlacklistedDomainsSetInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  reason?: InputMaybe<Scalars["String"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** Streaming cursor of the table "blacklisted_domains" */
export type BlacklistedDomainsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: BlacklistedDomainsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type BlacklistedDomainsStreamCursorValueInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  reason?: InputMaybe<Scalars["String"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** update columns of table "blacklisted_domains" */
export enum BlacklistedDomainsUpdateColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  REASON = "reason",
  /** column name */
  URL = "url",
}

export type BlacklistedDomainsUpdates = {
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<BlacklistedDomainsSetInput>;
  /** filter the rows which have to be updated */
  where: BlacklistedDomainsBoolExp;
};

/** columns and relationships of "blacklisted_urls" */
export type BlacklistedUrls = {
  __typename?: "blacklisted_urls";
  /** An object relationship */
  company?: Maybe<Companies>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamp"]["output"]>;
  id: Scalars["Int"]["output"];
  reason?: Maybe<Scalars["String"]["output"]>;
  url: Scalars["String"]["output"];
};

/** aggregated selection of "blacklisted_urls" */
export type BlacklistedUrlsAggregate = {
  __typename?: "blacklisted_urls_aggregate";
  aggregate?: Maybe<BlacklistedUrlsAggregateFields>;
  nodes: Array<BlacklistedUrls>;
};

export type BlacklistedUrlsAggregateBoolExp = {
  count?: InputMaybe<BlacklistedUrlsAggregateBoolExpCount>;
};

export type BlacklistedUrlsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<BlacklistedUrlsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<BlacklistedUrlsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "blacklisted_urls" */
export type BlacklistedUrlsAggregateFields = {
  __typename?: "blacklisted_urls_aggregate_fields";
  avg?: Maybe<BlacklistedUrlsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<BlacklistedUrlsMaxFields>;
  min?: Maybe<BlacklistedUrlsMinFields>;
  stddev?: Maybe<BlacklistedUrlsStddevFields>;
  stddev_pop?: Maybe<BlacklistedUrlsStddevPopFields>;
  stddev_samp?: Maybe<BlacklistedUrlsStddevSampFields>;
  sum?: Maybe<BlacklistedUrlsSumFields>;
  var_pop?: Maybe<BlacklistedUrlsVarPopFields>;
  var_samp?: Maybe<BlacklistedUrlsVarSampFields>;
  variance?: Maybe<BlacklistedUrlsVarianceFields>;
};

/** aggregate fields of "blacklisted_urls" */
export type BlacklistedUrlsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<BlacklistedUrlsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "blacklisted_urls" */
export type BlacklistedUrlsAggregateOrderBy = {
  avg?: InputMaybe<BlacklistedUrlsAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<BlacklistedUrlsMaxOrderBy>;
  min?: InputMaybe<BlacklistedUrlsMinOrderBy>;
  stddev?: InputMaybe<BlacklistedUrlsStddevOrderBy>;
  stddev_pop?: InputMaybe<BlacklistedUrlsStddevPopOrderBy>;
  stddev_samp?: InputMaybe<BlacklistedUrlsStddevSampOrderBy>;
  sum?: InputMaybe<BlacklistedUrlsSumOrderBy>;
  var_pop?: InputMaybe<BlacklistedUrlsVarPopOrderBy>;
  var_samp?: InputMaybe<BlacklistedUrlsVarSampOrderBy>;
  variance?: InputMaybe<BlacklistedUrlsVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "blacklisted_urls" */
export type BlacklistedUrlsArrRelInsertInput = {
  data: Array<BlacklistedUrlsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<BlacklistedUrlsOnConflict>;
};

/** aggregate avg on columns */
export type BlacklistedUrlsAvgFields = {
  __typename?: "blacklisted_urls_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "blacklisted_urls" */
export type BlacklistedUrlsAvgOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "blacklisted_urls". All fields are combined with a logical 'AND'. */
export type BlacklistedUrlsBoolExp = {
  _and?: InputMaybe<Array<BlacklistedUrlsBoolExp>>;
  _not?: InputMaybe<BlacklistedUrlsBoolExp>;
  _or?: InputMaybe<Array<BlacklistedUrlsBoolExp>>;
  company?: InputMaybe<CompaniesBoolExp>;
  company_id?: InputMaybe<UuidComparisonExp>;
  created_at?: InputMaybe<TimestampComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  reason?: InputMaybe<StringComparisonExp>;
  url?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "blacklisted_urls" */
export enum BlacklistedUrlsConstraint {
  /** unique or primary key constraint on columns "id" */
  BLACKLISTED_URLS_PKEY = "blacklisted_urls_pkey",
  /** unique or primary key constraint on columns "url" */
  BLACKLISTED_URLS_URL_KEY = "blacklisted_urls_url_key",
}

/** input type for incrementing numeric columns in table "blacklisted_urls" */
export type BlacklistedUrlsIncInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "blacklisted_urls" */
export type BlacklistedUrlsInsertInput = {
  company?: InputMaybe<CompaniesObjRelInsertInput>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  reason?: InputMaybe<Scalars["String"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type BlacklistedUrlsMaxFields = {
  __typename?: "blacklisted_urls_max_fields";
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamp"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  reason?: Maybe<Scalars["String"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** order by max() on columns of table "blacklisted_urls" */
export type BlacklistedUrlsMaxOrderBy = {
  company_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  reason?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type BlacklistedUrlsMinFields = {
  __typename?: "blacklisted_urls_min_fields";
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamp"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  reason?: Maybe<Scalars["String"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** order by min() on columns of table "blacklisted_urls" */
export type BlacklistedUrlsMinOrderBy = {
  company_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  reason?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "blacklisted_urls" */
export type BlacklistedUrlsMutationResponse = {
  __typename?: "blacklisted_urls_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<BlacklistedUrls>;
};

/** on_conflict condition type for table "blacklisted_urls" */
export type BlacklistedUrlsOnConflict = {
  constraint: BlacklistedUrlsConstraint;
  update_columns?: Array<BlacklistedUrlsUpdateColumn>;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
};

/** Ordering options when selecting data from "blacklisted_urls". */
export type BlacklistedUrlsOrderBy = {
  company?: InputMaybe<CompaniesOrderBy>;
  company_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  reason?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: blacklisted_urls */
export type BlacklistedUrlsPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "blacklisted_urls" */
export enum BlacklistedUrlsSelectColumn {
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  REASON = "reason",
  /** column name */
  URL = "url",
}

/** input type for updating data in table "blacklisted_urls" */
export type BlacklistedUrlsSetInput = {
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  reason?: InputMaybe<Scalars["String"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type BlacklistedUrlsStddevFields = {
  __typename?: "blacklisted_urls_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "blacklisted_urls" */
export type BlacklistedUrlsStddevOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type BlacklistedUrlsStddevPopFields = {
  __typename?: "blacklisted_urls_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "blacklisted_urls" */
export type BlacklistedUrlsStddevPopOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type BlacklistedUrlsStddevSampFields = {
  __typename?: "blacklisted_urls_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "blacklisted_urls" */
export type BlacklistedUrlsStddevSampOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "blacklisted_urls" */
export type BlacklistedUrlsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: BlacklistedUrlsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type BlacklistedUrlsStreamCursorValueInput = {
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  reason?: InputMaybe<Scalars["String"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type BlacklistedUrlsSumFields = {
  __typename?: "blacklisted_urls_sum_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "blacklisted_urls" */
export type BlacklistedUrlsSumOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** update columns of table "blacklisted_urls" */
export enum BlacklistedUrlsUpdateColumn {
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  REASON = "reason",
  /** column name */
  URL = "url",
}

export type BlacklistedUrlsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<BlacklistedUrlsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<BlacklistedUrlsSetInput>;
  /** filter the rows which have to be updated */
  where: BlacklistedUrlsBoolExp;
};

/** aggregate var_pop on columns */
export type BlacklistedUrlsVarPopFields = {
  __typename?: "blacklisted_urls_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "blacklisted_urls" */
export type BlacklistedUrlsVarPopOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type BlacklistedUrlsVarSampFields = {
  __typename?: "blacklisted_urls_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "blacklisted_urls" */
export type BlacklistedUrlsVarSampOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type BlacklistedUrlsVarianceFields = {
  __typename?: "blacklisted_urls_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "blacklisted_urls" */
export type BlacklistedUrlsVarianceOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** columns and relationships of "blocked_ips" */
export type BlockedIps = {
  __typename?: "blocked_ips";
  blocked_at?: Maybe<Scalars["timestamptz"]["output"]>;
  blocked_until: Scalars["timestamptz"]["output"];
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  failed_attempts?: Maybe<Scalars["Int"]["output"]>;
  id: Scalars["uuid"]["output"];
  ip_address: Scalars["inet"]["output"];
  reason?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregated selection of "blocked_ips" */
export type BlockedIpsAggregate = {
  __typename?: "blocked_ips_aggregate";
  aggregate?: Maybe<BlockedIpsAggregateFields>;
  nodes: Array<BlockedIps>;
};

/** aggregate fields of "blocked_ips" */
export type BlockedIpsAggregateFields = {
  __typename?: "blocked_ips_aggregate_fields";
  avg?: Maybe<BlockedIpsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<BlockedIpsMaxFields>;
  min?: Maybe<BlockedIpsMinFields>;
  stddev?: Maybe<BlockedIpsStddevFields>;
  stddev_pop?: Maybe<BlockedIpsStddevPopFields>;
  stddev_samp?: Maybe<BlockedIpsStddevSampFields>;
  sum?: Maybe<BlockedIpsSumFields>;
  var_pop?: Maybe<BlockedIpsVarPopFields>;
  var_samp?: Maybe<BlockedIpsVarSampFields>;
  variance?: Maybe<BlockedIpsVarianceFields>;
};

/** aggregate fields of "blocked_ips" */
export type BlockedIpsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<BlockedIpsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type BlockedIpsAvgFields = {
  __typename?: "blocked_ips_avg_fields";
  failed_attempts?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "blocked_ips". All fields are combined with a logical 'AND'. */
export type BlockedIpsBoolExp = {
  _and?: InputMaybe<Array<BlockedIpsBoolExp>>;
  _not?: InputMaybe<BlockedIpsBoolExp>;
  _or?: InputMaybe<Array<BlockedIpsBoolExp>>;
  blocked_at?: InputMaybe<TimestamptzComparisonExp>;
  blocked_until?: InputMaybe<TimestamptzComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  failed_attempts?: InputMaybe<IntComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  ip_address?: InputMaybe<InetComparisonExp>;
  reason?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
};

/** unique or primary key constraints on table "blocked_ips" */
export enum BlockedIpsConstraint {
  /** unique or primary key constraint on columns "id" */
  BLOCKED_IPS_PKEY = "blocked_ips_pkey",
}

/** input type for incrementing numeric columns in table "blocked_ips" */
export type BlockedIpsIncInput = {
  failed_attempts?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "blocked_ips" */
export type BlockedIpsInsertInput = {
  blocked_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  blocked_until?: InputMaybe<Scalars["timestamptz"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  failed_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  ip_address?: InputMaybe<Scalars["inet"]["input"]>;
  reason?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate max on columns */
export type BlockedIpsMaxFields = {
  __typename?: "blocked_ips_max_fields";
  blocked_at?: Maybe<Scalars["timestamptz"]["output"]>;
  blocked_until?: Maybe<Scalars["timestamptz"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  failed_attempts?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  reason?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregate min on columns */
export type BlockedIpsMinFields = {
  __typename?: "blocked_ips_min_fields";
  blocked_at?: Maybe<Scalars["timestamptz"]["output"]>;
  blocked_until?: Maybe<Scalars["timestamptz"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  failed_attempts?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  reason?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** response of any mutation on the table "blocked_ips" */
export type BlockedIpsMutationResponse = {
  __typename?: "blocked_ips_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<BlockedIps>;
};

/** on_conflict condition type for table "blocked_ips" */
export type BlockedIpsOnConflict = {
  constraint: BlockedIpsConstraint;
  update_columns?: Array<BlockedIpsUpdateColumn>;
  where?: InputMaybe<BlockedIpsBoolExp>;
};

/** Ordering options when selecting data from "blocked_ips". */
export type BlockedIpsOrderBy = {
  blocked_at?: InputMaybe<OrderBy>;
  blocked_until?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  failed_attempts?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  ip_address?: InputMaybe<OrderBy>;
  reason?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: blocked_ips */
export type BlockedIpsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "blocked_ips" */
export enum BlockedIpsSelectColumn {
  /** column name */
  BLOCKED_AT = "blocked_at",
  /** column name */
  BLOCKED_UNTIL = "blocked_until",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FAILED_ATTEMPTS = "failed_attempts",
  /** column name */
  ID = "id",
  /** column name */
  IP_ADDRESS = "ip_address",
  /** column name */
  REASON = "reason",
  /** column name */
  UPDATED_AT = "updated_at",
}

/** input type for updating data in table "blocked_ips" */
export type BlockedIpsSetInput = {
  blocked_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  blocked_until?: InputMaybe<Scalars["timestamptz"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  failed_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  ip_address?: InputMaybe<Scalars["inet"]["input"]>;
  reason?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate stddev on columns */
export type BlockedIpsStddevFields = {
  __typename?: "blocked_ips_stddev_fields";
  failed_attempts?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type BlockedIpsStddevPopFields = {
  __typename?: "blocked_ips_stddev_pop_fields";
  failed_attempts?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type BlockedIpsStddevSampFields = {
  __typename?: "blocked_ips_stddev_samp_fields";
  failed_attempts?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "blocked_ips" */
export type BlockedIpsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: BlockedIpsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type BlockedIpsStreamCursorValueInput = {
  blocked_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  blocked_until?: InputMaybe<Scalars["timestamptz"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  failed_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  ip_address?: InputMaybe<Scalars["inet"]["input"]>;
  reason?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate sum on columns */
export type BlockedIpsSumFields = {
  __typename?: "blocked_ips_sum_fields";
  failed_attempts?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "blocked_ips" */
export enum BlockedIpsUpdateColumn {
  /** column name */
  BLOCKED_AT = "blocked_at",
  /** column name */
  BLOCKED_UNTIL = "blocked_until",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FAILED_ATTEMPTS = "failed_attempts",
  /** column name */
  ID = "id",
  /** column name */
  IP_ADDRESS = "ip_address",
  /** column name */
  REASON = "reason",
  /** column name */
  UPDATED_AT = "updated_at",
}

export type BlockedIpsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<BlockedIpsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<BlockedIpsSetInput>;
  /** filter the rows which have to be updated */
  where: BlockedIpsBoolExp;
};

/** aggregate var_pop on columns */
export type BlockedIpsVarPopFields = {
  __typename?: "blocked_ips_var_pop_fields";
  failed_attempts?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type BlockedIpsVarSampFields = {
  __typename?: "blocked_ips_var_samp_fields";
  failed_attempts?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type BlockedIpsVarianceFields = {
  __typename?: "blocked_ips_variance_fields";
  failed_attempts?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "bookmark_folders" */
export type BookmarkFolders = {
  __typename?: "bookmark_folders";
  /** An object relationship */
  bookmark_folder?: Maybe<BookmarkFolders>;
  /** An array relationship */
  bookmark_folders: Array<BookmarkFolders>;
  /** An aggregate relationship */
  bookmark_folders_aggregate: BookmarkFoldersAggregate;
  /** An array relationship */
  bookmarks: Array<Bookmarks>;
  /** An aggregate relationship */
  bookmarks_aggregate: BookmarksAggregate;
  color?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id: Scalars["uuid"]["output"];
  is_default?: Maybe<Scalars["Boolean"]["output"]>;
  is_favorite?: Maybe<Scalars["Boolean"]["output"]>;
  name: Scalars["String"]["output"];
  parent_id?: Maybe<Scalars["uuid"]["output"]>;
  path?: Maybe<Scalars["ltree"]["output"]>;
  position?: Maybe<Scalars["Int"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id: Scalars["uuid"]["output"];
};

/** columns and relationships of "bookmark_folders" */
export type BookmarkFoldersBookmarkFoldersArgs = {
  distinct_on?: InputMaybe<Array<BookmarkFoldersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarkFoldersOrderBy>>;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
};

/** columns and relationships of "bookmark_folders" */
export type BookmarkFoldersBookmarkFoldersAggregateArgs = {
  distinct_on?: InputMaybe<Array<BookmarkFoldersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarkFoldersOrderBy>>;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
};

/** columns and relationships of "bookmark_folders" */
export type BookmarkFoldersBookmarksArgs = {
  distinct_on?: InputMaybe<Array<BookmarksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarksOrderBy>>;
  where?: InputMaybe<BookmarksBoolExp>;
};

/** columns and relationships of "bookmark_folders" */
export type BookmarkFoldersBookmarksAggregateArgs = {
  distinct_on?: InputMaybe<Array<BookmarksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarksOrderBy>>;
  where?: InputMaybe<BookmarksBoolExp>;
};

/** aggregated selection of "bookmark_folders" */
export type BookmarkFoldersAggregate = {
  __typename?: "bookmark_folders_aggregate";
  aggregate?: Maybe<BookmarkFoldersAggregateFields>;
  nodes: Array<BookmarkFolders>;
};

export type BookmarkFoldersAggregateBoolExp = {
  bool_and?: InputMaybe<BookmarkFoldersAggregateBoolExpBoolAnd>;
  bool_or?: InputMaybe<BookmarkFoldersAggregateBoolExpBoolOr>;
  count?: InputMaybe<BookmarkFoldersAggregateBoolExpCount>;
};

export type BookmarkFoldersAggregateBoolExpBoolAnd = {
  arguments: BookmarkFoldersSelectColumnBookmarkFoldersAggregateBoolExpBoolAndArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<BookmarkFoldersBoolExp>;
  predicate: BooleanComparisonExp;
};

export type BookmarkFoldersAggregateBoolExpBoolOr = {
  arguments: BookmarkFoldersSelectColumnBookmarkFoldersAggregateBoolExpBoolOrArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<BookmarkFoldersBoolExp>;
  predicate: BooleanComparisonExp;
};

export type BookmarkFoldersAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<BookmarkFoldersSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<BookmarkFoldersBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "bookmark_folders" */
export type BookmarkFoldersAggregateFields = {
  __typename?: "bookmark_folders_aggregate_fields";
  avg?: Maybe<BookmarkFoldersAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<BookmarkFoldersMaxFields>;
  min?: Maybe<BookmarkFoldersMinFields>;
  stddev?: Maybe<BookmarkFoldersStddevFields>;
  stddev_pop?: Maybe<BookmarkFoldersStddevPopFields>;
  stddev_samp?: Maybe<BookmarkFoldersStddevSampFields>;
  sum?: Maybe<BookmarkFoldersSumFields>;
  var_pop?: Maybe<BookmarkFoldersVarPopFields>;
  var_samp?: Maybe<BookmarkFoldersVarSampFields>;
  variance?: Maybe<BookmarkFoldersVarianceFields>;
};

/** aggregate fields of "bookmark_folders" */
export type BookmarkFoldersAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<BookmarkFoldersSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "bookmark_folders" */
export type BookmarkFoldersAggregateOrderBy = {
  avg?: InputMaybe<BookmarkFoldersAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<BookmarkFoldersMaxOrderBy>;
  min?: InputMaybe<BookmarkFoldersMinOrderBy>;
  stddev?: InputMaybe<BookmarkFoldersStddevOrderBy>;
  stddev_pop?: InputMaybe<BookmarkFoldersStddevPopOrderBy>;
  stddev_samp?: InputMaybe<BookmarkFoldersStddevSampOrderBy>;
  sum?: InputMaybe<BookmarkFoldersSumOrderBy>;
  var_pop?: InputMaybe<BookmarkFoldersVarPopOrderBy>;
  var_samp?: InputMaybe<BookmarkFoldersVarSampOrderBy>;
  variance?: InputMaybe<BookmarkFoldersVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "bookmark_folders" */
export type BookmarkFoldersArrRelInsertInput = {
  data: Array<BookmarkFoldersInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<BookmarkFoldersOnConflict>;
};

/** aggregate avg on columns */
export type BookmarkFoldersAvgFields = {
  __typename?: "bookmark_folders_avg_fields";
  position?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "bookmark_folders" */
export type BookmarkFoldersAvgOrderBy = {
  position?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "bookmark_folders". All fields are combined with a logical 'AND'. */
export type BookmarkFoldersBoolExp = {
  _and?: InputMaybe<Array<BookmarkFoldersBoolExp>>;
  _not?: InputMaybe<BookmarkFoldersBoolExp>;
  _or?: InputMaybe<Array<BookmarkFoldersBoolExp>>;
  bookmark_folder?: InputMaybe<BookmarkFoldersBoolExp>;
  bookmark_folders?: InputMaybe<BookmarkFoldersBoolExp>;
  bookmark_folders_aggregate?: InputMaybe<BookmarkFoldersAggregateBoolExp>;
  bookmarks?: InputMaybe<BookmarksBoolExp>;
  bookmarks_aggregate?: InputMaybe<BookmarksAggregateBoolExp>;
  color?: InputMaybe<StringComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  is_default?: InputMaybe<BooleanComparisonExp>;
  is_favorite?: InputMaybe<BooleanComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  parent_id?: InputMaybe<UuidComparisonExp>;
  path?: InputMaybe<LtreeComparisonExp>;
  position?: InputMaybe<IntComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
};

/** unique or primary key constraints on table "bookmark_folders" */
export enum BookmarkFoldersConstraint {
  /** unique or primary key constraint on columns "id" */
  BOOKMARK_FOLDERS_PKEY = "bookmark_folders_pkey",
  /** unique or primary key constraint on columns "user_id" */
  ONE_DEFAULT_PER_USER = "one_default_per_user",
}

/** input type for incrementing numeric columns in table "bookmark_folders" */
export type BookmarkFoldersIncInput = {
  position?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "bookmark_folders" */
export type BookmarkFoldersInsertInput = {
  bookmark_folder?: InputMaybe<BookmarkFoldersObjRelInsertInput>;
  bookmark_folders?: InputMaybe<BookmarkFoldersArrRelInsertInput>;
  bookmarks?: InputMaybe<BookmarksArrRelInsertInput>;
  color?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_default?: InputMaybe<Scalars["Boolean"]["input"]>;
  is_favorite?: InputMaybe<Scalars["Boolean"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  parent_id?: InputMaybe<Scalars["uuid"]["input"]>;
  path?: InputMaybe<Scalars["ltree"]["input"]>;
  position?: InputMaybe<Scalars["Int"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate max on columns */
export type BookmarkFoldersMaxFields = {
  __typename?: "bookmark_folders_max_fields";
  color?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  parent_id?: Maybe<Scalars["uuid"]["output"]>;
  path?: Maybe<Scalars["ltree"]["output"]>;
  position?: Maybe<Scalars["Int"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by max() on columns of table "bookmark_folders" */
export type BookmarkFoldersMaxOrderBy = {
  color?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  parent_id?: InputMaybe<OrderBy>;
  path?: InputMaybe<OrderBy>;
  position?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type BookmarkFoldersMinFields = {
  __typename?: "bookmark_folders_min_fields";
  color?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  parent_id?: Maybe<Scalars["uuid"]["output"]>;
  path?: Maybe<Scalars["ltree"]["output"]>;
  position?: Maybe<Scalars["Int"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by min() on columns of table "bookmark_folders" */
export type BookmarkFoldersMinOrderBy = {
  color?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  parent_id?: InputMaybe<OrderBy>;
  path?: InputMaybe<OrderBy>;
  position?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "bookmark_folders" */
export type BookmarkFoldersMutationResponse = {
  __typename?: "bookmark_folders_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<BookmarkFolders>;
};

/** input type for inserting object relation for remote table "bookmark_folders" */
export type BookmarkFoldersObjRelInsertInput = {
  data: BookmarkFoldersInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<BookmarkFoldersOnConflict>;
};

/** on_conflict condition type for table "bookmark_folders" */
export type BookmarkFoldersOnConflict = {
  constraint: BookmarkFoldersConstraint;
  update_columns?: Array<BookmarkFoldersUpdateColumn>;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
};

/** Ordering options when selecting data from "bookmark_folders". */
export type BookmarkFoldersOrderBy = {
  bookmark_folder?: InputMaybe<BookmarkFoldersOrderBy>;
  bookmark_folders_aggregate?: InputMaybe<BookmarkFoldersAggregateOrderBy>;
  bookmarks_aggregate?: InputMaybe<BookmarksAggregateOrderBy>;
  color?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  is_default?: InputMaybe<OrderBy>;
  is_favorite?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  parent_id?: InputMaybe<OrderBy>;
  path?: InputMaybe<OrderBy>;
  position?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: bookmark_folders */
export type BookmarkFoldersPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "bookmark_folders" */
export enum BookmarkFoldersSelectColumn {
  /** column name */
  COLOR = "color",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  IS_DEFAULT = "is_default",
  /** column name */
  IS_FAVORITE = "is_favorite",
  /** column name */
  NAME = "name",
  /** column name */
  PARENT_ID = "parent_id",
  /** column name */
  PATH = "path",
  /** column name */
  POSITION = "position",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

/** select "bookmark_folders_aggregate_bool_exp_bool_and_arguments_columns" columns of table "bookmark_folders" */
export enum BookmarkFoldersSelectColumnBookmarkFoldersAggregateBoolExpBoolAndArgumentsColumns {
  /** column name */
  IS_DEFAULT = "is_default",
  /** column name */
  IS_FAVORITE = "is_favorite",
}

/** select "bookmark_folders_aggregate_bool_exp_bool_or_arguments_columns" columns of table "bookmark_folders" */
export enum BookmarkFoldersSelectColumnBookmarkFoldersAggregateBoolExpBoolOrArgumentsColumns {
  /** column name */
  IS_DEFAULT = "is_default",
  /** column name */
  IS_FAVORITE = "is_favorite",
}

/** input type for updating data in table "bookmark_folders" */
export type BookmarkFoldersSetInput = {
  color?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_default?: InputMaybe<Scalars["Boolean"]["input"]>;
  is_favorite?: InputMaybe<Scalars["Boolean"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  parent_id?: InputMaybe<Scalars["uuid"]["input"]>;
  path?: InputMaybe<Scalars["ltree"]["input"]>;
  position?: InputMaybe<Scalars["Int"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate stddev on columns */
export type BookmarkFoldersStddevFields = {
  __typename?: "bookmark_folders_stddev_fields";
  position?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "bookmark_folders" */
export type BookmarkFoldersStddevOrderBy = {
  position?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type BookmarkFoldersStddevPopFields = {
  __typename?: "bookmark_folders_stddev_pop_fields";
  position?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "bookmark_folders" */
export type BookmarkFoldersStddevPopOrderBy = {
  position?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type BookmarkFoldersStddevSampFields = {
  __typename?: "bookmark_folders_stddev_samp_fields";
  position?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "bookmark_folders" */
export type BookmarkFoldersStddevSampOrderBy = {
  position?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "bookmark_folders" */
export type BookmarkFoldersStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: BookmarkFoldersStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type BookmarkFoldersStreamCursorValueInput = {
  color?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_default?: InputMaybe<Scalars["Boolean"]["input"]>;
  is_favorite?: InputMaybe<Scalars["Boolean"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  parent_id?: InputMaybe<Scalars["uuid"]["input"]>;
  path?: InputMaybe<Scalars["ltree"]["input"]>;
  position?: InputMaybe<Scalars["Int"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate sum on columns */
export type BookmarkFoldersSumFields = {
  __typename?: "bookmark_folders_sum_fields";
  position?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "bookmark_folders" */
export type BookmarkFoldersSumOrderBy = {
  position?: InputMaybe<OrderBy>;
};

/** update columns of table "bookmark_folders" */
export enum BookmarkFoldersUpdateColumn {
  /** column name */
  COLOR = "color",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  IS_DEFAULT = "is_default",
  /** column name */
  IS_FAVORITE = "is_favorite",
  /** column name */
  NAME = "name",
  /** column name */
  PARENT_ID = "parent_id",
  /** column name */
  PATH = "path",
  /** column name */
  POSITION = "position",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

export type BookmarkFoldersUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<BookmarkFoldersIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<BookmarkFoldersSetInput>;
  /** filter the rows which have to be updated */
  where: BookmarkFoldersBoolExp;
};

/** aggregate var_pop on columns */
export type BookmarkFoldersVarPopFields = {
  __typename?: "bookmark_folders_var_pop_fields";
  position?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "bookmark_folders" */
export type BookmarkFoldersVarPopOrderBy = {
  position?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type BookmarkFoldersVarSampFields = {
  __typename?: "bookmark_folders_var_samp_fields";
  position?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "bookmark_folders" */
export type BookmarkFoldersVarSampOrderBy = {
  position?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type BookmarkFoldersVarianceFields = {
  __typename?: "bookmark_folders_variance_fields";
  position?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "bookmark_folders" */
export type BookmarkFoldersVarianceOrderBy = {
  position?: InputMaybe<OrderBy>;
};

/** columns and relationships of "bookmarks" */
export type Bookmarks = {
  __typename?: "bookmarks";
  /** An object relationship */
  bookmark_folder?: Maybe<BookmarkFolders>;
  /** An object relationship */
  content: Contents;
  content_id: Scalars["uuid"]["output"];
  content_type: Scalars["String"]["output"];
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  folder_id?: Maybe<Scalars["uuid"]["output"]>;
  id: Scalars["uuid"]["output"];
  metadata?: Maybe<Scalars["jsonb"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id: Scalars["uuid"]["output"];
};

/** columns and relationships of "bookmarks" */
export type BookmarksMetadataArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "bookmarks" */
export type BookmarksAggregate = {
  __typename?: "bookmarks_aggregate";
  aggregate?: Maybe<BookmarksAggregateFields>;
  nodes: Array<Bookmarks>;
};

export type BookmarksAggregateBoolExp = {
  count?: InputMaybe<BookmarksAggregateBoolExpCount>;
};

export type BookmarksAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<BookmarksSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<BookmarksBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "bookmarks" */
export type BookmarksAggregateFields = {
  __typename?: "bookmarks_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<BookmarksMaxFields>;
  min?: Maybe<BookmarksMinFields>;
};

/** aggregate fields of "bookmarks" */
export type BookmarksAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<BookmarksSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "bookmarks" */
export type BookmarksAggregateOrderBy = {
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<BookmarksMaxOrderBy>;
  min?: InputMaybe<BookmarksMinOrderBy>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type BookmarksAppendInput = {
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** input type for inserting array relation for remote table "bookmarks" */
export type BookmarksArrRelInsertInput = {
  data: Array<BookmarksInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<BookmarksOnConflict>;
};

/** Boolean expression to filter rows from the table "bookmarks". All fields are combined with a logical 'AND'. */
export type BookmarksBoolExp = {
  _and?: InputMaybe<Array<BookmarksBoolExp>>;
  _not?: InputMaybe<BookmarksBoolExp>;
  _or?: InputMaybe<Array<BookmarksBoolExp>>;
  bookmark_folder?: InputMaybe<BookmarkFoldersBoolExp>;
  content?: InputMaybe<ContentsBoolExp>;
  content_id?: InputMaybe<UuidComparisonExp>;
  content_type?: InputMaybe<StringComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  folder_id?: InputMaybe<UuidComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  metadata?: InputMaybe<JsonbComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
};

/** unique or primary key constraints on table "bookmarks" */
export enum BookmarksConstraint {
  /** unique or primary key constraint on columns "id" */
  BOOKMARKS_PKEY = "bookmarks_pkey",
  /** unique or primary key constraint on columns "content_id", "user_id", "content_type" */
  BOOKMARKS_USER_ID_CONTENT_TYPE_CONTENT_ID_KEY = "bookmarks_user_id_content_type_content_id_key",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type BookmarksDeleteAtPathInput = {
  metadata?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type BookmarksDeleteElemInput = {
  metadata?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type BookmarksDeleteKeyInput = {
  metadata?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for inserting data into table "bookmarks" */
export type BookmarksInsertInput = {
  bookmark_folder?: InputMaybe<BookmarkFoldersObjRelInsertInput>;
  content?: InputMaybe<ContentsObjRelInsertInput>;
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_type?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  folder_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate max on columns */
export type BookmarksMaxFields = {
  __typename?: "bookmarks_max_fields";
  content_id?: Maybe<Scalars["uuid"]["output"]>;
  content_type?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  folder_id?: Maybe<Scalars["uuid"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by max() on columns of table "bookmarks" */
export type BookmarksMaxOrderBy = {
  content_id?: InputMaybe<OrderBy>;
  content_type?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  folder_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type BookmarksMinFields = {
  __typename?: "bookmarks_min_fields";
  content_id?: Maybe<Scalars["uuid"]["output"]>;
  content_type?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  folder_id?: Maybe<Scalars["uuid"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by min() on columns of table "bookmarks" */
export type BookmarksMinOrderBy = {
  content_id?: InputMaybe<OrderBy>;
  content_type?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  folder_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "bookmarks" */
export type BookmarksMutationResponse = {
  __typename?: "bookmarks_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Bookmarks>;
};

/** on_conflict condition type for table "bookmarks" */
export type BookmarksOnConflict = {
  constraint: BookmarksConstraint;
  update_columns?: Array<BookmarksUpdateColumn>;
  where?: InputMaybe<BookmarksBoolExp>;
};

/** Ordering options when selecting data from "bookmarks". */
export type BookmarksOrderBy = {
  bookmark_folder?: InputMaybe<BookmarkFoldersOrderBy>;
  content?: InputMaybe<ContentsOrderBy>;
  content_id?: InputMaybe<OrderBy>;
  content_type?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  folder_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  metadata?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: bookmarks */
export type BookmarksPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type BookmarksPrependInput = {
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "bookmarks" */
export enum BookmarksSelectColumn {
  /** column name */
  CONTENT_ID = "content_id",
  /** column name */
  CONTENT_TYPE = "content_type",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FOLDER_ID = "folder_id",
  /** column name */
  ID = "id",
  /** column name */
  METADATA = "metadata",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

/** input type for updating data in table "bookmarks" */
export type BookmarksSetInput = {
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_type?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  folder_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** Streaming cursor of the table "bookmarks" */
export type BookmarksStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: BookmarksStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type BookmarksStreamCursorValueInput = {
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_type?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  folder_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** update columns of table "bookmarks" */
export enum BookmarksUpdateColumn {
  /** column name */
  CONTENT_ID = "content_id",
  /** column name */
  CONTENT_TYPE = "content_type",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FOLDER_ID = "folder_id",
  /** column name */
  ID = "id",
  /** column name */
  METADATA = "metadata",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

export type BookmarksUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<BookmarksAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<BookmarksDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<BookmarksDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<BookmarksDeleteKeyInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<BookmarksPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<BookmarksSetInput>;
  /** filter the rows which have to be updated */
  where: BookmarksBoolExp;
};

/** columns and relationships of "business_domains" */
export type BusinessDomains = {
  __typename?: "business_domains";
  /** An object relationship */
  business_domain?: Maybe<BusinessDomains>;
  /** An array relationship */
  business_domains: Array<BusinessDomains>;
  /** An aggregate relationship */
  business_domains_aggregate: BusinessDomainsAggregate;
  /** An array relationship */
  categorized_urls: Array<CategorizedUrls>;
  /** An aggregate relationship */
  categorized_urls_aggregate: CategorizedUrlsAggregate;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["uuid"]["output"];
  name: Scalars["String"]["output"];
  parent_id?: Maybe<Scalars["uuid"]["output"]>;
  slug: Scalars["String"]["output"];
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** columns and relationships of "business_domains" */
export type BusinessDomainsBusinessDomainsArgs = {
  distinct_on?: InputMaybe<Array<BusinessDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BusinessDomainsOrderBy>>;
  where?: InputMaybe<BusinessDomainsBoolExp>;
};

/** columns and relationships of "business_domains" */
export type BusinessDomainsBusinessDomainsAggregateArgs = {
  distinct_on?: InputMaybe<Array<BusinessDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BusinessDomainsOrderBy>>;
  where?: InputMaybe<BusinessDomainsBoolExp>;
};

/** columns and relationships of "business_domains" */
export type BusinessDomainsCategorizedUrlsArgs = {
  distinct_on?: InputMaybe<Array<CategorizedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategorizedUrlsOrderBy>>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
};

/** columns and relationships of "business_domains" */
export type BusinessDomainsCategorizedUrlsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CategorizedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategorizedUrlsOrderBy>>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
};

/** aggregated selection of "business_domains" */
export type BusinessDomainsAggregate = {
  __typename?: "business_domains_aggregate";
  aggregate?: Maybe<BusinessDomainsAggregateFields>;
  nodes: Array<BusinessDomains>;
};

export type BusinessDomainsAggregateBoolExp = {
  count?: InputMaybe<BusinessDomainsAggregateBoolExpCount>;
};

export type BusinessDomainsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<BusinessDomainsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<BusinessDomainsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "business_domains" */
export type BusinessDomainsAggregateFields = {
  __typename?: "business_domains_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<BusinessDomainsMaxFields>;
  min?: Maybe<BusinessDomainsMinFields>;
};

/** aggregate fields of "business_domains" */
export type BusinessDomainsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<BusinessDomainsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "business_domains" */
export type BusinessDomainsAggregateOrderBy = {
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<BusinessDomainsMaxOrderBy>;
  min?: InputMaybe<BusinessDomainsMinOrderBy>;
};

/** input type for inserting array relation for remote table "business_domains" */
export type BusinessDomainsArrRelInsertInput = {
  data: Array<BusinessDomainsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<BusinessDomainsOnConflict>;
};

/** Boolean expression to filter rows from the table "business_domains". All fields are combined with a logical 'AND'. */
export type BusinessDomainsBoolExp = {
  _and?: InputMaybe<Array<BusinessDomainsBoolExp>>;
  _not?: InputMaybe<BusinessDomainsBoolExp>;
  _or?: InputMaybe<Array<BusinessDomainsBoolExp>>;
  business_domain?: InputMaybe<BusinessDomainsBoolExp>;
  business_domains?: InputMaybe<BusinessDomainsBoolExp>;
  business_domains_aggregate?: InputMaybe<BusinessDomainsAggregateBoolExp>;
  categorized_urls?: InputMaybe<CategorizedUrlsBoolExp>;
  categorized_urls_aggregate?: InputMaybe<CategorizedUrlsAggregateBoolExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  description?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  parent_id?: InputMaybe<UuidComparisonExp>;
  slug?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
};

/** unique or primary key constraints on table "business_domains" */
export enum BusinessDomainsConstraint {
  /** unique or primary key constraint on columns "id" */
  BUSINESS_DOMAINS_PKEY = "business_domains_pkey",
  /** unique or primary key constraint on columns "name" */
  UNIQUE_DOMAIN_NAME = "unique_domain_name",
  /** unique or primary key constraint on columns "slug" */
  UNIQUE_DOMAIN_SLUG = "unique_domain_slug",
}

/** input type for inserting data into table "business_domains" */
export type BusinessDomainsInsertInput = {
  business_domain?: InputMaybe<BusinessDomainsObjRelInsertInput>;
  business_domains?: InputMaybe<BusinessDomainsArrRelInsertInput>;
  categorized_urls?: InputMaybe<CategorizedUrlsArrRelInsertInput>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  parent_id?: InputMaybe<Scalars["uuid"]["input"]>;
  slug?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate max on columns */
export type BusinessDomainsMaxFields = {
  __typename?: "business_domains_max_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  parent_id?: Maybe<Scalars["uuid"]["output"]>;
  slug?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** order by max() on columns of table "business_domains" */
export type BusinessDomainsMaxOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  description?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  parent_id?: InputMaybe<OrderBy>;
  slug?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type BusinessDomainsMinFields = {
  __typename?: "business_domains_min_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  parent_id?: Maybe<Scalars["uuid"]["output"]>;
  slug?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** order by min() on columns of table "business_domains" */
export type BusinessDomainsMinOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  description?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  parent_id?: InputMaybe<OrderBy>;
  slug?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "business_domains" */
export type BusinessDomainsMutationResponse = {
  __typename?: "business_domains_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<BusinessDomains>;
};

/** input type for inserting object relation for remote table "business_domains" */
export type BusinessDomainsObjRelInsertInput = {
  data: BusinessDomainsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<BusinessDomainsOnConflict>;
};

/** on_conflict condition type for table "business_domains" */
export type BusinessDomainsOnConflict = {
  constraint: BusinessDomainsConstraint;
  update_columns?: Array<BusinessDomainsUpdateColumn>;
  where?: InputMaybe<BusinessDomainsBoolExp>;
};

/** Ordering options when selecting data from "business_domains". */
export type BusinessDomainsOrderBy = {
  business_domain?: InputMaybe<BusinessDomainsOrderBy>;
  business_domains_aggregate?: InputMaybe<BusinessDomainsAggregateOrderBy>;
  categorized_urls_aggregate?: InputMaybe<CategorizedUrlsAggregateOrderBy>;
  created_at?: InputMaybe<OrderBy>;
  description?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  parent_id?: InputMaybe<OrderBy>;
  slug?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: business_domains */
export type BusinessDomainsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "business_domains" */
export enum BusinessDomainsSelectColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
  /** column name */
  PARENT_ID = "parent_id",
  /** column name */
  SLUG = "slug",
  /** column name */
  UPDATED_AT = "updated_at",
}

/** input type for updating data in table "business_domains" */
export type BusinessDomainsSetInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  parent_id?: InputMaybe<Scalars["uuid"]["input"]>;
  slug?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** Streaming cursor of the table "business_domains" */
export type BusinessDomainsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: BusinessDomainsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type BusinessDomainsStreamCursorValueInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  parent_id?: InputMaybe<Scalars["uuid"]["input"]>;
  slug?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** update columns of table "business_domains" */
export enum BusinessDomainsUpdateColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
  /** column name */
  PARENT_ID = "parent_id",
  /** column name */
  SLUG = "slug",
  /** column name */
  UPDATED_AT = "updated_at",
}

export type BusinessDomainsUpdates = {
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<BusinessDomainsSetInput>;
  /** filter the rows which have to be updated */
  where: BusinessDomainsBoolExp;
};

/** columns and relationships of "categories" */
export type Categories = {
  __typename?: "categories";
  body?: Maybe<Scalars["String"]["output"]>;
  /** An array relationship */
  companies: Array<Companies>;
  /** An aggregate relationship */
  companies_aggregate: CompaniesAggregate;
  /** An array relationship */
  content_categories: Array<ContentCategories>;
  /** An aggregate relationship */
  content_categories_aggregate: ContentCategoriesAggregate;
  created_at: Scalars["timestamptz"]["output"];
  document_id?: Maybe<Scalars["String"]["output"]>;
  /** An array relationship */
  feed_categories: Array<FeedCategories>;
  /** An aggregate relationship */
  feed_categories_aggregate: FeedCategoriesAggregate;
  id: Scalars["bigint"]["output"];
  locale?: Maybe<Scalars["String"]["output"]>;
  name: Scalars["String"]["output"];
  /** An array relationship */
  news: Array<News>;
  /** An aggregate relationship */
  news_aggregate: NewsAggregate;
  published_at?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** columns and relationships of "categories" */
export type CategoriesCompaniesArgs = {
  distinct_on?: InputMaybe<Array<CompaniesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompaniesOrderBy>>;
  where?: InputMaybe<CompaniesBoolExp>;
};

/** columns and relationships of "categories" */
export type CategoriesCompaniesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompaniesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompaniesOrderBy>>;
  where?: InputMaybe<CompaniesBoolExp>;
};

/** columns and relationships of "categories" */
export type CategoriesContentCategoriesArgs = {
  distinct_on?: InputMaybe<Array<ContentCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentCategoriesOrderBy>>;
  where?: InputMaybe<ContentCategoriesBoolExp>;
};

/** columns and relationships of "categories" */
export type CategoriesContentCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentCategoriesOrderBy>>;
  where?: InputMaybe<ContentCategoriesBoolExp>;
};

/** columns and relationships of "categories" */
export type CategoriesFeedCategoriesArgs = {
  distinct_on?: InputMaybe<Array<FeedCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedCategoriesOrderBy>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

/** columns and relationships of "categories" */
export type CategoriesFeedCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeedCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedCategoriesOrderBy>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

/** columns and relationships of "categories" */
export type CategoriesNewsArgs = {
  distinct_on?: InputMaybe<Array<NewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsOrderBy>>;
  where?: InputMaybe<NewsBoolExp>;
};

/** columns and relationships of "categories" */
export type CategoriesNewsAggregateArgs = {
  distinct_on?: InputMaybe<Array<NewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsOrderBy>>;
  where?: InputMaybe<NewsBoolExp>;
};

/** aggregated selection of "categories" */
export type CategoriesAggregate = {
  __typename?: "categories_aggregate";
  aggregate?: Maybe<CategoriesAggregateFields>;
  nodes: Array<Categories>;
};

/** aggregate fields of "categories" */
export type CategoriesAggregateFields = {
  __typename?: "categories_aggregate_fields";
  avg?: Maybe<CategoriesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<CategoriesMaxFields>;
  min?: Maybe<CategoriesMinFields>;
  stddev?: Maybe<CategoriesStddevFields>;
  stddev_pop?: Maybe<CategoriesStddevPopFields>;
  stddev_samp?: Maybe<CategoriesStddevSampFields>;
  sum?: Maybe<CategoriesSumFields>;
  var_pop?: Maybe<CategoriesVarPopFields>;
  var_samp?: Maybe<CategoriesVarSampFields>;
  variance?: Maybe<CategoriesVarianceFields>;
};

/** aggregate fields of "categories" */
export type CategoriesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CategoriesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type CategoriesAvgFields = {
  __typename?: "categories_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "categories". All fields are combined with a logical 'AND'. */
export type CategoriesBoolExp = {
  _and?: InputMaybe<Array<CategoriesBoolExp>>;
  _not?: InputMaybe<CategoriesBoolExp>;
  _or?: InputMaybe<Array<CategoriesBoolExp>>;
  body?: InputMaybe<StringComparisonExp>;
  companies?: InputMaybe<CompaniesBoolExp>;
  companies_aggregate?: InputMaybe<CompaniesAggregateBoolExp>;
  content_categories?: InputMaybe<ContentCategoriesBoolExp>;
  content_categories_aggregate?: InputMaybe<ContentCategoriesAggregateBoolExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  document_id?: InputMaybe<StringComparisonExp>;
  feed_categories?: InputMaybe<FeedCategoriesBoolExp>;
  feed_categories_aggregate?: InputMaybe<FeedCategoriesAggregateBoolExp>;
  id?: InputMaybe<BigintComparisonExp>;
  locale?: InputMaybe<StringComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  news?: InputMaybe<NewsBoolExp>;
  news_aggregate?: InputMaybe<NewsAggregateBoolExp>;
  published_at?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
};

/** unique or primary key constraints on table "categories" */
export enum CategoriesConstraint {
  /** unique or primary key constraint on columns "id" */
  CATEGORIES_PKEY = "categories_pkey",
  /** unique or primary key constraint on columns "name" */
  CATEGORIES_TITLE_KEY = "categories_title_key",
}

/** input type for incrementing numeric columns in table "categories" */
export type CategoriesIncInput = {
  id?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** input type for inserting data into table "categories" */
export type CategoriesInsertInput = {
  body?: InputMaybe<Scalars["String"]["input"]>;
  companies?: InputMaybe<CompaniesArrRelInsertInput>;
  content_categories?: InputMaybe<ContentCategoriesArrRelInsertInput>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  document_id?: InputMaybe<Scalars["String"]["input"]>;
  feed_categories?: InputMaybe<FeedCategoriesArrRelInsertInput>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  locale?: InputMaybe<Scalars["String"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  news?: InputMaybe<NewsArrRelInsertInput>;
  published_at?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate max on columns */
export type CategoriesMaxFields = {
  __typename?: "categories_max_fields";
  body?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  document_id?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  locale?: Maybe<Scalars["String"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  published_at?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregate min on columns */
export type CategoriesMinFields = {
  __typename?: "categories_min_fields";
  body?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  document_id?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  locale?: Maybe<Scalars["String"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  published_at?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** response of any mutation on the table "categories" */
export type CategoriesMutationResponse = {
  __typename?: "categories_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Categories>;
};

/** input type for inserting object relation for remote table "categories" */
export type CategoriesObjRelInsertInput = {
  data: CategoriesInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<CategoriesOnConflict>;
};

/** on_conflict condition type for table "categories" */
export type CategoriesOnConflict = {
  constraint: CategoriesConstraint;
  update_columns?: Array<CategoriesUpdateColumn>;
  where?: InputMaybe<CategoriesBoolExp>;
};

/** Ordering options when selecting data from "categories". */
export type CategoriesOrderBy = {
  body?: InputMaybe<OrderBy>;
  companies_aggregate?: InputMaybe<CompaniesAggregateOrderBy>;
  content_categories_aggregate?: InputMaybe<ContentCategoriesAggregateOrderBy>;
  created_at?: InputMaybe<OrderBy>;
  document_id?: InputMaybe<OrderBy>;
  feed_categories_aggregate?: InputMaybe<FeedCategoriesAggregateOrderBy>;
  id?: InputMaybe<OrderBy>;
  locale?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  news_aggregate?: InputMaybe<NewsAggregateOrderBy>;
  published_at?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: categories */
export type CategoriesPkColumnsInput = {
  id: Scalars["bigint"]["input"];
};

/** select columns of table "categories" */
export enum CategoriesSelectColumn {
  /** column name */
  BODY = "body",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DOCUMENT_ID = "document_id",
  /** column name */
  ID = "id",
  /** column name */
  LOCALE = "locale",
  /** column name */
  NAME = "name",
  /** column name */
  PUBLISHED_AT = "published_at",
  /** column name */
  UPDATED_AT = "updated_at",
}

/** input type for updating data in table "categories" */
export type CategoriesSetInput = {
  body?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  document_id?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  locale?: InputMaybe<Scalars["String"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  published_at?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate stddev on columns */
export type CategoriesStddevFields = {
  __typename?: "categories_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type CategoriesStddevPopFields = {
  __typename?: "categories_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type CategoriesStddevSampFields = {
  __typename?: "categories_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "categories" */
export type CategoriesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CategoriesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CategoriesStreamCursorValueInput = {
  body?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  document_id?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  locale?: InputMaybe<Scalars["String"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  published_at?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate sum on columns */
export type CategoriesSumFields = {
  __typename?: "categories_sum_fields";
  id?: Maybe<Scalars["bigint"]["output"]>;
};

/** update columns of table "categories" */
export enum CategoriesUpdateColumn {
  /** column name */
  BODY = "body",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DOCUMENT_ID = "document_id",
  /** column name */
  ID = "id",
  /** column name */
  LOCALE = "locale",
  /** column name */
  NAME = "name",
  /** column name */
  PUBLISHED_AT = "published_at",
  /** column name */
  UPDATED_AT = "updated_at",
}

export type CategoriesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<CategoriesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CategoriesSetInput>;
  /** filter the rows which have to be updated */
  where: CategoriesBoolExp;
};

/** aggregate var_pop on columns */
export type CategoriesVarPopFields = {
  __typename?: "categories_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type CategoriesVarSampFields = {
  __typename?: "categories_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type CategoriesVarianceFields = {
  __typename?: "categories_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "categorized_urls" */
export type CategorizedUrls = {
  __typename?: "categorized_urls";
  /** An object relationship */
  business_domain: BusinessDomains;
  categorizer_version: Scalars["String"]["output"];
  /** An object relationship */
  company?: Maybe<Companies>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  confidence: Scalars["numeric"]["output"];
  content_hash?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  domain_id: Scalars["uuid"]["output"];
  found_on?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["uuid"]["output"];
  priority?: Maybe<Scalars["smallint"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url: Scalars["String"]["output"];
};

/** aggregated selection of "categorized_urls" */
export type CategorizedUrlsAggregate = {
  __typename?: "categorized_urls_aggregate";
  aggregate?: Maybe<CategorizedUrlsAggregateFields>;
  nodes: Array<CategorizedUrls>;
};

export type CategorizedUrlsAggregateBoolExp = {
  count?: InputMaybe<CategorizedUrlsAggregateBoolExpCount>;
};

export type CategorizedUrlsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<CategorizedUrlsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CategorizedUrlsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "categorized_urls" */
export type CategorizedUrlsAggregateFields = {
  __typename?: "categorized_urls_aggregate_fields";
  avg?: Maybe<CategorizedUrlsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<CategorizedUrlsMaxFields>;
  min?: Maybe<CategorizedUrlsMinFields>;
  stddev?: Maybe<CategorizedUrlsStddevFields>;
  stddev_pop?: Maybe<CategorizedUrlsStddevPopFields>;
  stddev_samp?: Maybe<CategorizedUrlsStddevSampFields>;
  sum?: Maybe<CategorizedUrlsSumFields>;
  var_pop?: Maybe<CategorizedUrlsVarPopFields>;
  var_samp?: Maybe<CategorizedUrlsVarSampFields>;
  variance?: Maybe<CategorizedUrlsVarianceFields>;
};

/** aggregate fields of "categorized_urls" */
export type CategorizedUrlsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CategorizedUrlsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "categorized_urls" */
export type CategorizedUrlsAggregateOrderBy = {
  avg?: InputMaybe<CategorizedUrlsAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<CategorizedUrlsMaxOrderBy>;
  min?: InputMaybe<CategorizedUrlsMinOrderBy>;
  stddev?: InputMaybe<CategorizedUrlsStddevOrderBy>;
  stddev_pop?: InputMaybe<CategorizedUrlsStddevPopOrderBy>;
  stddev_samp?: InputMaybe<CategorizedUrlsStddevSampOrderBy>;
  sum?: InputMaybe<CategorizedUrlsSumOrderBy>;
  var_pop?: InputMaybe<CategorizedUrlsVarPopOrderBy>;
  var_samp?: InputMaybe<CategorizedUrlsVarSampOrderBy>;
  variance?: InputMaybe<CategorizedUrlsVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "categorized_urls" */
export type CategorizedUrlsArrRelInsertInput = {
  data: Array<CategorizedUrlsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<CategorizedUrlsOnConflict>;
};

/** aggregate avg on columns */
export type CategorizedUrlsAvgFields = {
  __typename?: "categorized_urls_avg_fields";
  confidence?: Maybe<Scalars["Float"]["output"]>;
  priority?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "categorized_urls" */
export type CategorizedUrlsAvgOrderBy = {
  confidence?: InputMaybe<OrderBy>;
  priority?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "categorized_urls". All fields are combined with a logical 'AND'. */
export type CategorizedUrlsBoolExp = {
  _and?: InputMaybe<Array<CategorizedUrlsBoolExp>>;
  _not?: InputMaybe<CategorizedUrlsBoolExp>;
  _or?: InputMaybe<Array<CategorizedUrlsBoolExp>>;
  business_domain?: InputMaybe<BusinessDomainsBoolExp>;
  categorizer_version?: InputMaybe<StringComparisonExp>;
  company?: InputMaybe<CompaniesBoolExp>;
  company_id?: InputMaybe<UuidComparisonExp>;
  confidence?: InputMaybe<NumericComparisonExp>;
  content_hash?: InputMaybe<StringComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  domain_id?: InputMaybe<UuidComparisonExp>;
  found_on?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  priority?: InputMaybe<SmallintComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  url?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "categorized_urls" */
export enum CategorizedUrlsConstraint {
  /** unique or primary key constraint on columns "id" */
  CATEGORIZED_URLS_PKEY = "categorized_urls_pkey",
  /** unique or primary key constraint on columns "found_on", "url" */
  UNIQUE_URL_FOUND_ON = "unique_url_found_on",
}

/** input type for incrementing numeric columns in table "categorized_urls" */
export type CategorizedUrlsIncInput = {
  confidence?: InputMaybe<Scalars["numeric"]["input"]>;
  priority?: InputMaybe<Scalars["smallint"]["input"]>;
};

/** input type for inserting data into table "categorized_urls" */
export type CategorizedUrlsInsertInput = {
  business_domain?: InputMaybe<BusinessDomainsObjRelInsertInput>;
  categorizer_version?: InputMaybe<Scalars["String"]["input"]>;
  company?: InputMaybe<CompaniesObjRelInsertInput>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  confidence?: InputMaybe<Scalars["numeric"]["input"]>;
  content_hash?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  domain_id?: InputMaybe<Scalars["uuid"]["input"]>;
  found_on?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  priority?: InputMaybe<Scalars["smallint"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type CategorizedUrlsMaxFields = {
  __typename?: "categorized_urls_max_fields";
  categorizer_version?: Maybe<Scalars["String"]["output"]>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  confidence?: Maybe<Scalars["numeric"]["output"]>;
  content_hash?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  domain_id?: Maybe<Scalars["uuid"]["output"]>;
  found_on?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  priority?: Maybe<Scalars["smallint"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** order by max() on columns of table "categorized_urls" */
export type CategorizedUrlsMaxOrderBy = {
  categorizer_version?: InputMaybe<OrderBy>;
  company_id?: InputMaybe<OrderBy>;
  confidence?: InputMaybe<OrderBy>;
  content_hash?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  domain_id?: InputMaybe<OrderBy>;
  found_on?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  priority?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type CategorizedUrlsMinFields = {
  __typename?: "categorized_urls_min_fields";
  categorizer_version?: Maybe<Scalars["String"]["output"]>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  confidence?: Maybe<Scalars["numeric"]["output"]>;
  content_hash?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  domain_id?: Maybe<Scalars["uuid"]["output"]>;
  found_on?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  priority?: Maybe<Scalars["smallint"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** order by min() on columns of table "categorized_urls" */
export type CategorizedUrlsMinOrderBy = {
  categorizer_version?: InputMaybe<OrderBy>;
  company_id?: InputMaybe<OrderBy>;
  confidence?: InputMaybe<OrderBy>;
  content_hash?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  domain_id?: InputMaybe<OrderBy>;
  found_on?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  priority?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "categorized_urls" */
export type CategorizedUrlsMutationResponse = {
  __typename?: "categorized_urls_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<CategorizedUrls>;
};

/** on_conflict condition type for table "categorized_urls" */
export type CategorizedUrlsOnConflict = {
  constraint: CategorizedUrlsConstraint;
  update_columns?: Array<CategorizedUrlsUpdateColumn>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
};

/** Ordering options when selecting data from "categorized_urls". */
export type CategorizedUrlsOrderBy = {
  business_domain?: InputMaybe<BusinessDomainsOrderBy>;
  categorizer_version?: InputMaybe<OrderBy>;
  company?: InputMaybe<CompaniesOrderBy>;
  company_id?: InputMaybe<OrderBy>;
  confidence?: InputMaybe<OrderBy>;
  content_hash?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  domain_id?: InputMaybe<OrderBy>;
  found_on?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  priority?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: categorized_urls */
export type CategorizedUrlsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "categorized_urls" */
export enum CategorizedUrlsSelectColumn {
  /** column name */
  CATEGORIZER_VERSION = "categorizer_version",
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CONFIDENCE = "confidence",
  /** column name */
  CONTENT_HASH = "content_hash",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DOMAIN_ID = "domain_id",
  /** column name */
  FOUND_ON = "found_on",
  /** column name */
  ID = "id",
  /** column name */
  PRIORITY = "priority",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
}

/** input type for updating data in table "categorized_urls" */
export type CategorizedUrlsSetInput = {
  categorizer_version?: InputMaybe<Scalars["String"]["input"]>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  confidence?: InputMaybe<Scalars["numeric"]["input"]>;
  content_hash?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  domain_id?: InputMaybe<Scalars["uuid"]["input"]>;
  found_on?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  priority?: InputMaybe<Scalars["smallint"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type CategorizedUrlsStddevFields = {
  __typename?: "categorized_urls_stddev_fields";
  confidence?: Maybe<Scalars["Float"]["output"]>;
  priority?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "categorized_urls" */
export type CategorizedUrlsStddevOrderBy = {
  confidence?: InputMaybe<OrderBy>;
  priority?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type CategorizedUrlsStddevPopFields = {
  __typename?: "categorized_urls_stddev_pop_fields";
  confidence?: Maybe<Scalars["Float"]["output"]>;
  priority?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "categorized_urls" */
export type CategorizedUrlsStddevPopOrderBy = {
  confidence?: InputMaybe<OrderBy>;
  priority?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type CategorizedUrlsStddevSampFields = {
  __typename?: "categorized_urls_stddev_samp_fields";
  confidence?: Maybe<Scalars["Float"]["output"]>;
  priority?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "categorized_urls" */
export type CategorizedUrlsStddevSampOrderBy = {
  confidence?: InputMaybe<OrderBy>;
  priority?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "categorized_urls" */
export type CategorizedUrlsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CategorizedUrlsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CategorizedUrlsStreamCursorValueInput = {
  categorizer_version?: InputMaybe<Scalars["String"]["input"]>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  confidence?: InputMaybe<Scalars["numeric"]["input"]>;
  content_hash?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  domain_id?: InputMaybe<Scalars["uuid"]["input"]>;
  found_on?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  priority?: InputMaybe<Scalars["smallint"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type CategorizedUrlsSumFields = {
  __typename?: "categorized_urls_sum_fields";
  confidence?: Maybe<Scalars["numeric"]["output"]>;
  priority?: Maybe<Scalars["smallint"]["output"]>;
};

/** order by sum() on columns of table "categorized_urls" */
export type CategorizedUrlsSumOrderBy = {
  confidence?: InputMaybe<OrderBy>;
  priority?: InputMaybe<OrderBy>;
};

/** update columns of table "categorized_urls" */
export enum CategorizedUrlsUpdateColumn {
  /** column name */
  CATEGORIZER_VERSION = "categorizer_version",
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CONFIDENCE = "confidence",
  /** column name */
  CONTENT_HASH = "content_hash",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DOMAIN_ID = "domain_id",
  /** column name */
  FOUND_ON = "found_on",
  /** column name */
  ID = "id",
  /** column name */
  PRIORITY = "priority",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
}

export type CategorizedUrlsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<CategorizedUrlsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CategorizedUrlsSetInput>;
  /** filter the rows which have to be updated */
  where: CategorizedUrlsBoolExp;
};

/** aggregate var_pop on columns */
export type CategorizedUrlsVarPopFields = {
  __typename?: "categorized_urls_var_pop_fields";
  confidence?: Maybe<Scalars["Float"]["output"]>;
  priority?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "categorized_urls" */
export type CategorizedUrlsVarPopOrderBy = {
  confidence?: InputMaybe<OrderBy>;
  priority?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type CategorizedUrlsVarSampFields = {
  __typename?: "categorized_urls_var_samp_fields";
  confidence?: Maybe<Scalars["Float"]["output"]>;
  priority?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "categorized_urls" */
export type CategorizedUrlsVarSampOrderBy = {
  confidence?: InputMaybe<OrderBy>;
  priority?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type CategorizedUrlsVarianceFields = {
  __typename?: "categorized_urls_variance_fields";
  confidence?: Maybe<Scalars["Float"]["output"]>;
  priority?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "categorized_urls" */
export type CategorizedUrlsVarianceOrderBy = {
  confidence?: InputMaybe<OrderBy>;
  priority?: InputMaybe<OrderBy>;
};

/** columns and relationships of "circuit_breaker_states" */
export type CircuitBreakerStates = {
  __typename?: "circuit_breaker_states";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  failure_count?: Maybe<Scalars["Int"]["output"]>;
  id: Scalars["uuid"]["output"];
  job_name: Scalars["String"]["output"];
  last_failure?: Maybe<Scalars["timestamptz"]["output"]>;
  last_success?: Maybe<Scalars["timestamptz"]["output"]>;
  state: Scalars["String"]["output"];
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregated selection of "circuit_breaker_states" */
export type CircuitBreakerStatesAggregate = {
  __typename?: "circuit_breaker_states_aggregate";
  aggregate?: Maybe<CircuitBreakerStatesAggregateFields>;
  nodes: Array<CircuitBreakerStates>;
};

/** aggregate fields of "circuit_breaker_states" */
export type CircuitBreakerStatesAggregateFields = {
  __typename?: "circuit_breaker_states_aggregate_fields";
  avg?: Maybe<CircuitBreakerStatesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<CircuitBreakerStatesMaxFields>;
  min?: Maybe<CircuitBreakerStatesMinFields>;
  stddev?: Maybe<CircuitBreakerStatesStddevFields>;
  stddev_pop?: Maybe<CircuitBreakerStatesStddevPopFields>;
  stddev_samp?: Maybe<CircuitBreakerStatesStddevSampFields>;
  sum?: Maybe<CircuitBreakerStatesSumFields>;
  var_pop?: Maybe<CircuitBreakerStatesVarPopFields>;
  var_samp?: Maybe<CircuitBreakerStatesVarSampFields>;
  variance?: Maybe<CircuitBreakerStatesVarianceFields>;
};

/** aggregate fields of "circuit_breaker_states" */
export type CircuitBreakerStatesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CircuitBreakerStatesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type CircuitBreakerStatesAvgFields = {
  __typename?: "circuit_breaker_states_avg_fields";
  failure_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "circuit_breaker_states". All fields are combined with a logical 'AND'. */
export type CircuitBreakerStatesBoolExp = {
  _and?: InputMaybe<Array<CircuitBreakerStatesBoolExp>>;
  _not?: InputMaybe<CircuitBreakerStatesBoolExp>;
  _or?: InputMaybe<Array<CircuitBreakerStatesBoolExp>>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  failure_count?: InputMaybe<IntComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  job_name?: InputMaybe<StringComparisonExp>;
  last_failure?: InputMaybe<TimestamptzComparisonExp>;
  last_success?: InputMaybe<TimestamptzComparisonExp>;
  state?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
};

/** unique or primary key constraints on table "circuit_breaker_states" */
export enum CircuitBreakerStatesConstraint {
  /** unique or primary key constraint on columns "job_name" */
  CIRCUIT_BREAKER_STATES_JOB_NAME_KEY = "circuit_breaker_states_job_name_key",
  /** unique or primary key constraint on columns "id" */
  CIRCUIT_BREAKER_STATES_PKEY = "circuit_breaker_states_pkey",
}

/** input type for incrementing numeric columns in table "circuit_breaker_states" */
export type CircuitBreakerStatesIncInput = {
  failure_count?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "circuit_breaker_states" */
export type CircuitBreakerStatesInsertInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  failure_count?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  job_name?: InputMaybe<Scalars["String"]["input"]>;
  last_failure?: InputMaybe<Scalars["timestamptz"]["input"]>;
  last_success?: InputMaybe<Scalars["timestamptz"]["input"]>;
  state?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate max on columns */
export type CircuitBreakerStatesMaxFields = {
  __typename?: "circuit_breaker_states_max_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  failure_count?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  job_name?: Maybe<Scalars["String"]["output"]>;
  last_failure?: Maybe<Scalars["timestamptz"]["output"]>;
  last_success?: Maybe<Scalars["timestamptz"]["output"]>;
  state?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregate min on columns */
export type CircuitBreakerStatesMinFields = {
  __typename?: "circuit_breaker_states_min_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  failure_count?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  job_name?: Maybe<Scalars["String"]["output"]>;
  last_failure?: Maybe<Scalars["timestamptz"]["output"]>;
  last_success?: Maybe<Scalars["timestamptz"]["output"]>;
  state?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** response of any mutation on the table "circuit_breaker_states" */
export type CircuitBreakerStatesMutationResponse = {
  __typename?: "circuit_breaker_states_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<CircuitBreakerStates>;
};

/** on_conflict condition type for table "circuit_breaker_states" */
export type CircuitBreakerStatesOnConflict = {
  constraint: CircuitBreakerStatesConstraint;
  update_columns?: Array<CircuitBreakerStatesUpdateColumn>;
  where?: InputMaybe<CircuitBreakerStatesBoolExp>;
};

/** Ordering options when selecting data from "circuit_breaker_states". */
export type CircuitBreakerStatesOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  failure_count?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  job_name?: InputMaybe<OrderBy>;
  last_failure?: InputMaybe<OrderBy>;
  last_success?: InputMaybe<OrderBy>;
  state?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: circuit_breaker_states */
export type CircuitBreakerStatesPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "circuit_breaker_states" */
export enum CircuitBreakerStatesSelectColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FAILURE_COUNT = "failure_count",
  /** column name */
  ID = "id",
  /** column name */
  JOB_NAME = "job_name",
  /** column name */
  LAST_FAILURE = "last_failure",
  /** column name */
  LAST_SUCCESS = "last_success",
  /** column name */
  STATE = "state",
  /** column name */
  UPDATED_AT = "updated_at",
}

/** input type for updating data in table "circuit_breaker_states" */
export type CircuitBreakerStatesSetInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  failure_count?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  job_name?: InputMaybe<Scalars["String"]["input"]>;
  last_failure?: InputMaybe<Scalars["timestamptz"]["input"]>;
  last_success?: InputMaybe<Scalars["timestamptz"]["input"]>;
  state?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate stddev on columns */
export type CircuitBreakerStatesStddevFields = {
  __typename?: "circuit_breaker_states_stddev_fields";
  failure_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type CircuitBreakerStatesStddevPopFields = {
  __typename?: "circuit_breaker_states_stddev_pop_fields";
  failure_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type CircuitBreakerStatesStddevSampFields = {
  __typename?: "circuit_breaker_states_stddev_samp_fields";
  failure_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "circuit_breaker_states" */
export type CircuitBreakerStatesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CircuitBreakerStatesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CircuitBreakerStatesStreamCursorValueInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  failure_count?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  job_name?: InputMaybe<Scalars["String"]["input"]>;
  last_failure?: InputMaybe<Scalars["timestamptz"]["input"]>;
  last_success?: InputMaybe<Scalars["timestamptz"]["input"]>;
  state?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate sum on columns */
export type CircuitBreakerStatesSumFields = {
  __typename?: "circuit_breaker_states_sum_fields";
  failure_count?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "circuit_breaker_states" */
export enum CircuitBreakerStatesUpdateColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FAILURE_COUNT = "failure_count",
  /** column name */
  ID = "id",
  /** column name */
  JOB_NAME = "job_name",
  /** column name */
  LAST_FAILURE = "last_failure",
  /** column name */
  LAST_SUCCESS = "last_success",
  /** column name */
  STATE = "state",
  /** column name */
  UPDATED_AT = "updated_at",
}

export type CircuitBreakerStatesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<CircuitBreakerStatesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CircuitBreakerStatesSetInput>;
  /** filter the rows which have to be updated */
  where: CircuitBreakerStatesBoolExp;
};

/** aggregate var_pop on columns */
export type CircuitBreakerStatesVarPopFields = {
  __typename?: "circuit_breaker_states_var_pop_fields";
  failure_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type CircuitBreakerStatesVarSampFields = {
  __typename?: "circuit_breaker_states_var_samp_fields";
  failure_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type CircuitBreakerStatesVarianceFields = {
  __typename?: "circuit_breaker_states_variance_fields";
  failure_count?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "cities" */
export type Cities = {
  __typename?: "cities";
  /** An array relationship */
  addresses: Array<Addresses>;
  /** An aggregate relationship */
  addresses_aggregate: AddressesAggregate;
  /** An object relationship */
  country: Countries;
  country_id: Scalars["Int"]["output"];
  id: Scalars["Int"]["output"];
  name: Scalars["String"]["output"];
  state?: Maybe<Scalars["String"]["output"]>;
};

/** columns and relationships of "cities" */
export type CitiesAddressesArgs = {
  distinct_on?: InputMaybe<Array<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

/** columns and relationships of "cities" */
export type CitiesAddressesAggregateArgs = {
  distinct_on?: InputMaybe<Array<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

/** aggregated selection of "cities" */
export type CitiesAggregate = {
  __typename?: "cities_aggregate";
  aggregate?: Maybe<CitiesAggregateFields>;
  nodes: Array<Cities>;
};

export type CitiesAggregateBoolExp = {
  count?: InputMaybe<CitiesAggregateBoolExpCount>;
};

export type CitiesAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<CitiesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CitiesBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "cities" */
export type CitiesAggregateFields = {
  __typename?: "cities_aggregate_fields";
  avg?: Maybe<CitiesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<CitiesMaxFields>;
  min?: Maybe<CitiesMinFields>;
  stddev?: Maybe<CitiesStddevFields>;
  stddev_pop?: Maybe<CitiesStddevPopFields>;
  stddev_samp?: Maybe<CitiesStddevSampFields>;
  sum?: Maybe<CitiesSumFields>;
  var_pop?: Maybe<CitiesVarPopFields>;
  var_samp?: Maybe<CitiesVarSampFields>;
  variance?: Maybe<CitiesVarianceFields>;
};

/** aggregate fields of "cities" */
export type CitiesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CitiesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "cities" */
export type CitiesAggregateOrderBy = {
  avg?: InputMaybe<CitiesAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<CitiesMaxOrderBy>;
  min?: InputMaybe<CitiesMinOrderBy>;
  stddev?: InputMaybe<CitiesStddevOrderBy>;
  stddev_pop?: InputMaybe<CitiesStddevPopOrderBy>;
  stddev_samp?: InputMaybe<CitiesStddevSampOrderBy>;
  sum?: InputMaybe<CitiesSumOrderBy>;
  var_pop?: InputMaybe<CitiesVarPopOrderBy>;
  var_samp?: InputMaybe<CitiesVarSampOrderBy>;
  variance?: InputMaybe<CitiesVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "cities" */
export type CitiesArrRelInsertInput = {
  data: Array<CitiesInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<CitiesOnConflict>;
};

/** aggregate avg on columns */
export type CitiesAvgFields = {
  __typename?: "cities_avg_fields";
  country_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "cities" */
export type CitiesAvgOrderBy = {
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "cities". All fields are combined with a logical 'AND'. */
export type CitiesBoolExp = {
  _and?: InputMaybe<Array<CitiesBoolExp>>;
  _not?: InputMaybe<CitiesBoolExp>;
  _or?: InputMaybe<Array<CitiesBoolExp>>;
  addresses?: InputMaybe<AddressesBoolExp>;
  addresses_aggregate?: InputMaybe<AddressesAggregateBoolExp>;
  country?: InputMaybe<CountriesBoolExp>;
  country_id?: InputMaybe<IntComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  state?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "cities" */
export enum CitiesConstraint {
  /** unique or primary key constraint on columns "name" */
  CITIES_NAME_KEY = "cities_name_key",
  /** unique or primary key constraint on columns "id" */
  CITIES_PKEY = "cities_pkey",
}

/** input type for incrementing numeric columns in table "cities" */
export type CitiesIncInput = {
  country_id?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "cities" */
export type CitiesInsertInput = {
  addresses?: InputMaybe<AddressesArrRelInsertInput>;
  country?: InputMaybe<CountriesObjRelInsertInput>;
  country_id?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  state?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type CitiesMaxFields = {
  __typename?: "cities_max_fields";
  country_id?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  state?: Maybe<Scalars["String"]["output"]>;
};

/** order by max() on columns of table "cities" */
export type CitiesMaxOrderBy = {
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  state?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type CitiesMinFields = {
  __typename?: "cities_min_fields";
  country_id?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  state?: Maybe<Scalars["String"]["output"]>;
};

/** order by min() on columns of table "cities" */
export type CitiesMinOrderBy = {
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  state?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "cities" */
export type CitiesMutationResponse = {
  __typename?: "cities_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Cities>;
};

/** input type for inserting object relation for remote table "cities" */
export type CitiesObjRelInsertInput = {
  data: CitiesInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<CitiesOnConflict>;
};

/** on_conflict condition type for table "cities" */
export type CitiesOnConflict = {
  constraint: CitiesConstraint;
  update_columns?: Array<CitiesUpdateColumn>;
  where?: InputMaybe<CitiesBoolExp>;
};

/** Ordering options when selecting data from "cities". */
export type CitiesOrderBy = {
  addresses_aggregate?: InputMaybe<AddressesAggregateOrderBy>;
  country?: InputMaybe<CountriesOrderBy>;
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  state?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: cities */
export type CitiesPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "cities" */
export enum CitiesSelectColumn {
  /** column name */
  COUNTRY_ID = "country_id",
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
  /** column name */
  STATE = "state",
}

/** input type for updating data in table "cities" */
export type CitiesSetInput = {
  country_id?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  state?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type CitiesStddevFields = {
  __typename?: "cities_stddev_fields";
  country_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "cities" */
export type CitiesStddevOrderBy = {
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type CitiesStddevPopFields = {
  __typename?: "cities_stddev_pop_fields";
  country_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "cities" */
export type CitiesStddevPopOrderBy = {
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type CitiesStddevSampFields = {
  __typename?: "cities_stddev_samp_fields";
  country_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "cities" */
export type CitiesStddevSampOrderBy = {
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "cities" */
export type CitiesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CitiesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CitiesStreamCursorValueInput = {
  country_id?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  state?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type CitiesSumFields = {
  __typename?: "cities_sum_fields";
  country_id?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "cities" */
export type CitiesSumOrderBy = {
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** update columns of table "cities" */
export enum CitiesUpdateColumn {
  /** column name */
  COUNTRY_ID = "country_id",
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
  /** column name */
  STATE = "state",
}

export type CitiesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<CitiesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CitiesSetInput>;
  /** filter the rows which have to be updated */
  where: CitiesBoolExp;
};

/** aggregate var_pop on columns */
export type CitiesVarPopFields = {
  __typename?: "cities_var_pop_fields";
  country_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "cities" */
export type CitiesVarPopOrderBy = {
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type CitiesVarSampFields = {
  __typename?: "cities_var_samp_fields";
  country_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "cities" */
export type CitiesVarSampOrderBy = {
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type CitiesVarianceFields = {
  __typename?: "cities_variance_fields";
  country_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "cities" */
export type CitiesVarianceOrderBy = {
  country_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** columns and relationships of "comments" */
export type Comments = {
  __typename?: "comments";
  /** An object relationship */
  comment?: Maybe<Comments>;
  /** An array relationship */
  comments: Array<Comments>;
  /** An aggregate relationship */
  comments_aggregate: CommentsAggregate;
  content: Scalars["String"]["output"];
  content_id: Scalars["uuid"]["output"];
  content_type: Scalars["content_type"]["output"];
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id: Scalars["uuid"]["output"];
  parent_comment_id?: Maybe<Scalars["uuid"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id: Scalars["uuid"]["output"];
  /** An object relationship */
  user_profile: UserProfiles;
};

/** columns and relationships of "comments" */
export type CommentsCommentsArgs = {
  distinct_on?: InputMaybe<Array<CommentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CommentsOrderBy>>;
  where?: InputMaybe<CommentsBoolExp>;
};

/** columns and relationships of "comments" */
export type CommentsCommentsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CommentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CommentsOrderBy>>;
  where?: InputMaybe<CommentsBoolExp>;
};

/** aggregated selection of "comments" */
export type CommentsAggregate = {
  __typename?: "comments_aggregate";
  aggregate?: Maybe<CommentsAggregateFields>;
  nodes: Array<Comments>;
};

export type CommentsAggregateBoolExp = {
  count?: InputMaybe<CommentsAggregateBoolExpCount>;
};

export type CommentsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<CommentsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CommentsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "comments" */
export type CommentsAggregateFields = {
  __typename?: "comments_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<CommentsMaxFields>;
  min?: Maybe<CommentsMinFields>;
};

/** aggregate fields of "comments" */
export type CommentsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CommentsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "comments" */
export type CommentsAggregateOrderBy = {
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<CommentsMaxOrderBy>;
  min?: InputMaybe<CommentsMinOrderBy>;
};

/** input type for inserting array relation for remote table "comments" */
export type CommentsArrRelInsertInput = {
  data: Array<CommentsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<CommentsOnConflict>;
};

/** Boolean expression to filter rows from the table "comments". All fields are combined with a logical 'AND'. */
export type CommentsBoolExp = {
  _and?: InputMaybe<Array<CommentsBoolExp>>;
  _not?: InputMaybe<CommentsBoolExp>;
  _or?: InputMaybe<Array<CommentsBoolExp>>;
  comment?: InputMaybe<CommentsBoolExp>;
  comments?: InputMaybe<CommentsBoolExp>;
  comments_aggregate?: InputMaybe<CommentsAggregateBoolExp>;
  content?: InputMaybe<StringComparisonExp>;
  content_id?: InputMaybe<UuidComparisonExp>;
  content_type?: InputMaybe<ContentTypeComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  parent_comment_id?: InputMaybe<UuidComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
  user_profile?: InputMaybe<UserProfilesBoolExp>;
};

/** unique or primary key constraints on table "comments" */
export enum CommentsConstraint {
  /** unique or primary key constraint on columns "id" */
  COMMENTS_PKEY = "comments_pkey",
}

/** input type for inserting data into table "comments" */
export type CommentsInsertInput = {
  comment?: InputMaybe<CommentsObjRelInsertInput>;
  comments?: InputMaybe<CommentsArrRelInsertInput>;
  content?: InputMaybe<Scalars["String"]["input"]>;
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  parent_comment_id?: InputMaybe<Scalars["uuid"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
};

/** aggregate max on columns */
export type CommentsMaxFields = {
  __typename?: "comments_max_fields";
  content?: Maybe<Scalars["String"]["output"]>;
  content_id?: Maybe<Scalars["uuid"]["output"]>;
  content_type?: Maybe<Scalars["content_type"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  parent_comment_id?: Maybe<Scalars["uuid"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by max() on columns of table "comments" */
export type CommentsMaxOrderBy = {
  content?: InputMaybe<OrderBy>;
  content_id?: InputMaybe<OrderBy>;
  content_type?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  parent_comment_id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type CommentsMinFields = {
  __typename?: "comments_min_fields";
  content?: Maybe<Scalars["String"]["output"]>;
  content_id?: Maybe<Scalars["uuid"]["output"]>;
  content_type?: Maybe<Scalars["content_type"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  parent_comment_id?: Maybe<Scalars["uuid"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by min() on columns of table "comments" */
export type CommentsMinOrderBy = {
  content?: InputMaybe<OrderBy>;
  content_id?: InputMaybe<OrderBy>;
  content_type?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  parent_comment_id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "comments" */
export type CommentsMutationResponse = {
  __typename?: "comments_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Comments>;
};

/** input type for inserting object relation for remote table "comments" */
export type CommentsObjRelInsertInput = {
  data: CommentsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<CommentsOnConflict>;
};

/** on_conflict condition type for table "comments" */
export type CommentsOnConflict = {
  constraint: CommentsConstraint;
  update_columns?: Array<CommentsUpdateColumn>;
  where?: InputMaybe<CommentsBoolExp>;
};

/** Ordering options when selecting data from "comments". */
export type CommentsOrderBy = {
  comment?: InputMaybe<CommentsOrderBy>;
  comments_aggregate?: InputMaybe<CommentsAggregateOrderBy>;
  content?: InputMaybe<OrderBy>;
  content_id?: InputMaybe<OrderBy>;
  content_type?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  parent_comment_id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  user_profile?: InputMaybe<UserProfilesOrderBy>;
};

/** primary key columns input for table: comments */
export type CommentsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "comments" */
export enum CommentsSelectColumn {
  /** column name */
  CONTENT = "content",
  /** column name */
  CONTENT_ID = "content_id",
  /** column name */
  CONTENT_TYPE = "content_type",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  PARENT_COMMENT_ID = "parent_comment_id",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

/** input type for updating data in table "comments" */
export type CommentsSetInput = {
  content?: InputMaybe<Scalars["String"]["input"]>;
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  parent_comment_id?: InputMaybe<Scalars["uuid"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** Streaming cursor of the table "comments" */
export type CommentsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CommentsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CommentsStreamCursorValueInput = {
  content?: InputMaybe<Scalars["String"]["input"]>;
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  parent_comment_id?: InputMaybe<Scalars["uuid"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** update columns of table "comments" */
export enum CommentsUpdateColumn {
  /** column name */
  CONTENT = "content",
  /** column name */
  CONTENT_ID = "content_id",
  /** column name */
  CONTENT_TYPE = "content_type",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  PARENT_COMMENT_ID = "parent_comment_id",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

export type CommentsUpdates = {
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CommentsSetInput>;
  /** filter the rows which have to be updated */
  where: CommentsBoolExp;
};

/** columns and relationships of "companies" */
export type Companies = {
  __typename?: "companies";
  /** An array relationship */
  addresses: Array<Addresses>;
  /** An aggregate relationship */
  addresses_aggregate: AddressesAggregate;
  /** An array relationship */
  ads: Array<Ads>;
  /** An aggregate relationship */
  ads_aggregate: AdsAggregate;
  /** An array relationship */
  blacklisted_urls: Array<BlacklistedUrls>;
  /** An aggregate relationship */
  blacklisted_urls_aggregate: BlacklistedUrlsAggregate;
  /** An array relationship */
  categorized_urls: Array<CategorizedUrls>;
  /** An aggregate relationship */
  categorized_urls_aggregate: CategorizedUrlsAggregate;
  category?: Maybe<Scalars["String"]["output"]>;
  /** An object relationship */
  categoryByCategoryId?: Maybe<Categories>;
  category_id?: Maybe<Scalars["bigint"]["output"]>;
  /** An array relationship */
  company_contacts: Array<CompanyContacts>;
  /** An aggregate relationship */
  company_contacts_aggregate: CompanyContactsAggregate;
  /** An array relationship */
  company_extras: Array<CompanyExtras>;
  /** An aggregate relationship */
  company_extras_aggregate: CompanyExtrasAggregate;
  /** An array relationship */
  contacts: Array<Contacts>;
  /** An aggregate relationship */
  contacts_aggregate: ContactsAggregate;
  /** An array relationship */
  content_sources: Array<ContentSources>;
  /** An aggregate relationship */
  content_sources_aggregate: ContentSourcesAggregate;
  content_status: Scalars["content_status"]["output"];
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  failed_count?: Maybe<Scalars["smallint"]["output"]>;
  founding_year?: Maybe<Scalars["smallint"]["output"]>;
  id: Scalars["uuid"]["output"];
  is_english?: Maybe<Scalars["Boolean"]["output"]>;
  is_government?: Maybe<Scalars["Boolean"]["output"]>;
  keywords?: Maybe<Scalars["jsonb"]["output"]>;
  logo_url?: Maybe<Scalars["String"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  /** An array relationship */
  news: Array<News>;
  /** An aggregate relationship */
  news_aggregate: NewsAggregate;
  scrape_frequency?: Maybe<Scalars["scrape_frequency"]["output"]>;
  scrape_rating?: Maybe<Scalars["smallint"]["output"]>;
  scraped_at?: Maybe<Scalars["timestamptz"]["output"]>;
  social_media_id?: Maybe<Scalars["Int"]["output"]>;
  /** An object relationship */
  social_medium?: Maybe<SocialMedia>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url: Scalars["String"]["output"];
};

/** columns and relationships of "companies" */
export type CompaniesAddressesArgs = {
  distinct_on?: InputMaybe<Array<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesAddressesAggregateArgs = {
  distinct_on?: InputMaybe<Array<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesAdsArgs = {
  distinct_on?: InputMaybe<Array<AdsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdsOrderBy>>;
  where?: InputMaybe<AdsBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesAdsAggregateArgs = {
  distinct_on?: InputMaybe<Array<AdsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdsOrderBy>>;
  where?: InputMaybe<AdsBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesBlacklistedUrlsArgs = {
  distinct_on?: InputMaybe<Array<BlacklistedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlacklistedUrlsOrderBy>>;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesBlacklistedUrlsAggregateArgs = {
  distinct_on?: InputMaybe<Array<BlacklistedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlacklistedUrlsOrderBy>>;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesCategorizedUrlsArgs = {
  distinct_on?: InputMaybe<Array<CategorizedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategorizedUrlsOrderBy>>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesCategorizedUrlsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CategorizedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategorizedUrlsOrderBy>>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesCompanyContactsArgs = {
  distinct_on?: InputMaybe<Array<CompanyContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyContactsOrderBy>>;
  where?: InputMaybe<CompanyContactsBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesCompanyContactsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompanyContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyContactsOrderBy>>;
  where?: InputMaybe<CompanyContactsBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesCompanyExtrasArgs = {
  distinct_on?: InputMaybe<Array<CompanyExtrasSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyExtrasOrderBy>>;
  where?: InputMaybe<CompanyExtrasBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesCompanyExtrasAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompanyExtrasSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyExtrasOrderBy>>;
  where?: InputMaybe<CompanyExtrasBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesContactsArgs = {
  distinct_on?: InputMaybe<Array<ContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContactsOrderBy>>;
  where?: InputMaybe<ContactsBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesContactsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContactsOrderBy>>;
  where?: InputMaybe<ContactsBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesContentSourcesArgs = {
  distinct_on?: InputMaybe<Array<ContentSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourcesOrderBy>>;
  where?: InputMaybe<ContentSourcesBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesContentSourcesAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourcesOrderBy>>;
  where?: InputMaybe<ContentSourcesBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesKeywordsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "companies" */
export type CompaniesNewsArgs = {
  distinct_on?: InputMaybe<Array<NewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsOrderBy>>;
  where?: InputMaybe<NewsBoolExp>;
};

/** columns and relationships of "companies" */
export type CompaniesNewsAggregateArgs = {
  distinct_on?: InputMaybe<Array<NewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsOrderBy>>;
  where?: InputMaybe<NewsBoolExp>;
};

/** aggregated selection of "companies" */
export type CompaniesAggregate = {
  __typename?: "companies_aggregate";
  aggregate?: Maybe<CompaniesAggregateFields>;
  nodes: Array<Companies>;
};

export type CompaniesAggregateBoolExp = {
  bool_and?: InputMaybe<CompaniesAggregateBoolExpBoolAnd>;
  bool_or?: InputMaybe<CompaniesAggregateBoolExpBoolOr>;
  count?: InputMaybe<CompaniesAggregateBoolExpCount>;
};

export type CompaniesAggregateBoolExpBoolAnd = {
  arguments: CompaniesSelectColumnCompaniesAggregateBoolExpBoolAndArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CompaniesBoolExp>;
  predicate: BooleanComparisonExp;
};

export type CompaniesAggregateBoolExpBoolOr = {
  arguments: CompaniesSelectColumnCompaniesAggregateBoolExpBoolOrArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CompaniesBoolExp>;
  predicate: BooleanComparisonExp;
};

export type CompaniesAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<CompaniesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CompaniesBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "companies" */
export type CompaniesAggregateFields = {
  __typename?: "companies_aggregate_fields";
  avg?: Maybe<CompaniesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<CompaniesMaxFields>;
  min?: Maybe<CompaniesMinFields>;
  stddev?: Maybe<CompaniesStddevFields>;
  stddev_pop?: Maybe<CompaniesStddevPopFields>;
  stddev_samp?: Maybe<CompaniesStddevSampFields>;
  sum?: Maybe<CompaniesSumFields>;
  var_pop?: Maybe<CompaniesVarPopFields>;
  var_samp?: Maybe<CompaniesVarSampFields>;
  variance?: Maybe<CompaniesVarianceFields>;
};

/** aggregate fields of "companies" */
export type CompaniesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CompaniesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "companies" */
export type CompaniesAggregateOrderBy = {
  avg?: InputMaybe<CompaniesAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<CompaniesMaxOrderBy>;
  min?: InputMaybe<CompaniesMinOrderBy>;
  stddev?: InputMaybe<CompaniesStddevOrderBy>;
  stddev_pop?: InputMaybe<CompaniesStddevPopOrderBy>;
  stddev_samp?: InputMaybe<CompaniesStddevSampOrderBy>;
  sum?: InputMaybe<CompaniesSumOrderBy>;
  var_pop?: InputMaybe<CompaniesVarPopOrderBy>;
  var_samp?: InputMaybe<CompaniesVarSampOrderBy>;
  variance?: InputMaybe<CompaniesVarianceOrderBy>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type CompaniesAppendInput = {
  keywords?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** input type for inserting array relation for remote table "companies" */
export type CompaniesArrRelInsertInput = {
  data: Array<CompaniesInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<CompaniesOnConflict>;
};

/** aggregate avg on columns */
export type CompaniesAvgFields = {
  __typename?: "companies_avg_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  founding_year?: Maybe<Scalars["Float"]["output"]>;
  scrape_rating?: Maybe<Scalars["Float"]["output"]>;
  social_media_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "companies" */
export type CompaniesAvgOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  founding_year?: InputMaybe<OrderBy>;
  scrape_rating?: InputMaybe<OrderBy>;
  social_media_id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "companies". All fields are combined with a logical 'AND'. */
export type CompaniesBoolExp = {
  _and?: InputMaybe<Array<CompaniesBoolExp>>;
  _not?: InputMaybe<CompaniesBoolExp>;
  _or?: InputMaybe<Array<CompaniesBoolExp>>;
  addresses?: InputMaybe<AddressesBoolExp>;
  addresses_aggregate?: InputMaybe<AddressesAggregateBoolExp>;
  ads?: InputMaybe<AdsBoolExp>;
  ads_aggregate?: InputMaybe<AdsAggregateBoolExp>;
  blacklisted_urls?: InputMaybe<BlacklistedUrlsBoolExp>;
  blacklisted_urls_aggregate?: InputMaybe<BlacklistedUrlsAggregateBoolExp>;
  categorized_urls?: InputMaybe<CategorizedUrlsBoolExp>;
  categorized_urls_aggregate?: InputMaybe<CategorizedUrlsAggregateBoolExp>;
  category?: InputMaybe<StringComparisonExp>;
  categoryByCategoryId?: InputMaybe<CategoriesBoolExp>;
  category_id?: InputMaybe<BigintComparisonExp>;
  company_contacts?: InputMaybe<CompanyContactsBoolExp>;
  company_contacts_aggregate?: InputMaybe<CompanyContactsAggregateBoolExp>;
  company_extras?: InputMaybe<CompanyExtrasBoolExp>;
  company_extras_aggregate?: InputMaybe<CompanyExtrasAggregateBoolExp>;
  contacts?: InputMaybe<ContactsBoolExp>;
  contacts_aggregate?: InputMaybe<ContactsAggregateBoolExp>;
  content_sources?: InputMaybe<ContentSourcesBoolExp>;
  content_sources_aggregate?: InputMaybe<ContentSourcesAggregateBoolExp>;
  content_status?: InputMaybe<ContentStatusComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  description?: InputMaybe<StringComparisonExp>;
  failed_count?: InputMaybe<SmallintComparisonExp>;
  founding_year?: InputMaybe<SmallintComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  is_english?: InputMaybe<BooleanComparisonExp>;
  is_government?: InputMaybe<BooleanComparisonExp>;
  keywords?: InputMaybe<JsonbComparisonExp>;
  logo_url?: InputMaybe<StringComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  news?: InputMaybe<NewsBoolExp>;
  news_aggregate?: InputMaybe<NewsAggregateBoolExp>;
  scrape_frequency?: InputMaybe<ScrapeFrequencyComparisonExp>;
  scrape_rating?: InputMaybe<SmallintComparisonExp>;
  scraped_at?: InputMaybe<TimestamptzComparisonExp>;
  social_media_id?: InputMaybe<IntComparisonExp>;
  social_medium?: InputMaybe<SocialMediaBoolExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  url?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "companies" */
export enum CompaniesConstraint {
  /** unique or primary key constraint on columns "id" */
  COMPANIES_ID_KEY1 = "companies_id_key1",
  /** unique or primary key constraint on columns "id" */
  COMPANIES_PKEY = "companies_pkey",
  /** unique or primary key constraint on columns "url" */
  COMPANIES_WEBSITE_URL_KEY = "companies_website_url_key",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type CompaniesDeleteAtPathInput = {
  keywords?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type CompaniesDeleteElemInput = {
  keywords?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type CompaniesDeleteKeyInput = {
  keywords?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for incrementing numeric columns in table "companies" */
export type CompaniesIncInput = {
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  founding_year?: InputMaybe<Scalars["smallint"]["input"]>;
  scrape_rating?: InputMaybe<Scalars["smallint"]["input"]>;
  social_media_id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "companies" */
export type CompaniesInsertInput = {
  addresses?: InputMaybe<AddressesArrRelInsertInput>;
  ads?: InputMaybe<AdsArrRelInsertInput>;
  blacklisted_urls?: InputMaybe<BlacklistedUrlsArrRelInsertInput>;
  categorized_urls?: InputMaybe<CategorizedUrlsArrRelInsertInput>;
  category?: InputMaybe<Scalars["String"]["input"]>;
  categoryByCategoryId?: InputMaybe<CategoriesObjRelInsertInput>;
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  company_contacts?: InputMaybe<CompanyContactsArrRelInsertInput>;
  company_extras?: InputMaybe<CompanyExtrasArrRelInsertInput>;
  contacts?: InputMaybe<ContactsArrRelInsertInput>;
  content_sources?: InputMaybe<ContentSourcesArrRelInsertInput>;
  content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  founding_year?: InputMaybe<Scalars["smallint"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_english?: InputMaybe<Scalars["Boolean"]["input"]>;
  is_government?: InputMaybe<Scalars["Boolean"]["input"]>;
  keywords?: InputMaybe<Scalars["jsonb"]["input"]>;
  logo_url?: InputMaybe<Scalars["String"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  news?: InputMaybe<NewsArrRelInsertInput>;
  scrape_frequency?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  scrape_rating?: InputMaybe<Scalars["smallint"]["input"]>;
  scraped_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  social_media_id?: InputMaybe<Scalars["Int"]["input"]>;
  social_medium?: InputMaybe<SocialMediaObjRelInsertInput>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type CompaniesMaxFields = {
  __typename?: "companies_max_fields";
  category?: Maybe<Scalars["String"]["output"]>;
  category_id?: Maybe<Scalars["bigint"]["output"]>;
  content_status?: Maybe<Scalars["content_status"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  failed_count?: Maybe<Scalars["smallint"]["output"]>;
  founding_year?: Maybe<Scalars["smallint"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  logo_url?: Maybe<Scalars["String"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  scrape_frequency?: Maybe<Scalars["scrape_frequency"]["output"]>;
  scrape_rating?: Maybe<Scalars["smallint"]["output"]>;
  scraped_at?: Maybe<Scalars["timestamptz"]["output"]>;
  social_media_id?: Maybe<Scalars["Int"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** order by max() on columns of table "companies" */
export type CompaniesMaxOrderBy = {
  category?: InputMaybe<OrderBy>;
  category_id?: InputMaybe<OrderBy>;
  content_status?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  description?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  founding_year?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  logo_url?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  scrape_frequency?: InputMaybe<OrderBy>;
  scrape_rating?: InputMaybe<OrderBy>;
  scraped_at?: InputMaybe<OrderBy>;
  social_media_id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type CompaniesMinFields = {
  __typename?: "companies_min_fields";
  category?: Maybe<Scalars["String"]["output"]>;
  category_id?: Maybe<Scalars["bigint"]["output"]>;
  content_status?: Maybe<Scalars["content_status"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  failed_count?: Maybe<Scalars["smallint"]["output"]>;
  founding_year?: Maybe<Scalars["smallint"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  logo_url?: Maybe<Scalars["String"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  scrape_frequency?: Maybe<Scalars["scrape_frequency"]["output"]>;
  scrape_rating?: Maybe<Scalars["smallint"]["output"]>;
  scraped_at?: Maybe<Scalars["timestamptz"]["output"]>;
  social_media_id?: Maybe<Scalars["Int"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** order by min() on columns of table "companies" */
export type CompaniesMinOrderBy = {
  category?: InputMaybe<OrderBy>;
  category_id?: InputMaybe<OrderBy>;
  content_status?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  description?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  founding_year?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  logo_url?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  scrape_frequency?: InputMaybe<OrderBy>;
  scrape_rating?: InputMaybe<OrderBy>;
  scraped_at?: InputMaybe<OrderBy>;
  social_media_id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "companies" */
export type CompaniesMutationResponse = {
  __typename?: "companies_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Companies>;
};

/** input type for inserting object relation for remote table "companies" */
export type CompaniesObjRelInsertInput = {
  data: CompaniesInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<CompaniesOnConflict>;
};

/** on_conflict condition type for table "companies" */
export type CompaniesOnConflict = {
  constraint: CompaniesConstraint;
  update_columns?: Array<CompaniesUpdateColumn>;
  where?: InputMaybe<CompaniesBoolExp>;
};

/** Ordering options when selecting data from "companies". */
export type CompaniesOrderBy = {
  addresses_aggregate?: InputMaybe<AddressesAggregateOrderBy>;
  ads_aggregate?: InputMaybe<AdsAggregateOrderBy>;
  blacklisted_urls_aggregate?: InputMaybe<BlacklistedUrlsAggregateOrderBy>;
  categorized_urls_aggregate?: InputMaybe<CategorizedUrlsAggregateOrderBy>;
  category?: InputMaybe<OrderBy>;
  categoryByCategoryId?: InputMaybe<CategoriesOrderBy>;
  category_id?: InputMaybe<OrderBy>;
  company_contacts_aggregate?: InputMaybe<CompanyContactsAggregateOrderBy>;
  company_extras_aggregate?: InputMaybe<CompanyExtrasAggregateOrderBy>;
  contacts_aggregate?: InputMaybe<ContactsAggregateOrderBy>;
  content_sources_aggregate?: InputMaybe<ContentSourcesAggregateOrderBy>;
  content_status?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  description?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  founding_year?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  is_english?: InputMaybe<OrderBy>;
  is_government?: InputMaybe<OrderBy>;
  keywords?: InputMaybe<OrderBy>;
  logo_url?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  news_aggregate?: InputMaybe<NewsAggregateOrderBy>;
  scrape_frequency?: InputMaybe<OrderBy>;
  scrape_rating?: InputMaybe<OrderBy>;
  scraped_at?: InputMaybe<OrderBy>;
  social_media_id?: InputMaybe<OrderBy>;
  social_medium?: InputMaybe<SocialMediaOrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: companies */
export type CompaniesPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type CompaniesPrependInput = {
  keywords?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "companies" */
export enum CompaniesSelectColumn {
  /** column name */
  CATEGORY = "category",
  /** column name */
  CATEGORY_ID = "category_id",
  /** column name */
  CONTENT_STATUS = "content_status",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  FAILED_COUNT = "failed_count",
  /** column name */
  FOUNDING_YEAR = "founding_year",
  /** column name */
  ID = "id",
  /** column name */
  IS_ENGLISH = "is_english",
  /** column name */
  IS_GOVERNMENT = "is_government",
  /** column name */
  KEYWORDS = "keywords",
  /** column name */
  LOGO_URL = "logo_url",
  /** column name */
  NAME = "name",
  /** column name */
  SCRAPE_FREQUENCY = "scrape_frequency",
  /** column name */
  SCRAPE_RATING = "scrape_rating",
  /** column name */
  SCRAPED_AT = "scraped_at",
  /** column name */
  SOCIAL_MEDIA_ID = "social_media_id",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
}

/** select "companies_aggregate_bool_exp_bool_and_arguments_columns" columns of table "companies" */
export enum CompaniesSelectColumnCompaniesAggregateBoolExpBoolAndArgumentsColumns {
  /** column name */
  IS_ENGLISH = "is_english",
  /** column name */
  IS_GOVERNMENT = "is_government",
}

/** select "companies_aggregate_bool_exp_bool_or_arguments_columns" columns of table "companies" */
export enum CompaniesSelectColumnCompaniesAggregateBoolExpBoolOrArgumentsColumns {
  /** column name */
  IS_ENGLISH = "is_english",
  /** column name */
  IS_GOVERNMENT = "is_government",
}

/** input type for updating data in table "companies" */
export type CompaniesSetInput = {
  category?: InputMaybe<Scalars["String"]["input"]>;
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  founding_year?: InputMaybe<Scalars["smallint"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_english?: InputMaybe<Scalars["Boolean"]["input"]>;
  is_government?: InputMaybe<Scalars["Boolean"]["input"]>;
  keywords?: InputMaybe<Scalars["jsonb"]["input"]>;
  logo_url?: InputMaybe<Scalars["String"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  scrape_frequency?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  scrape_rating?: InputMaybe<Scalars["smallint"]["input"]>;
  scraped_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  social_media_id?: InputMaybe<Scalars["Int"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type CompaniesStddevFields = {
  __typename?: "companies_stddev_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  founding_year?: Maybe<Scalars["Float"]["output"]>;
  scrape_rating?: Maybe<Scalars["Float"]["output"]>;
  social_media_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "companies" */
export type CompaniesStddevOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  founding_year?: InputMaybe<OrderBy>;
  scrape_rating?: InputMaybe<OrderBy>;
  social_media_id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type CompaniesStddevPopFields = {
  __typename?: "companies_stddev_pop_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  founding_year?: Maybe<Scalars["Float"]["output"]>;
  scrape_rating?: Maybe<Scalars["Float"]["output"]>;
  social_media_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "companies" */
export type CompaniesStddevPopOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  founding_year?: InputMaybe<OrderBy>;
  scrape_rating?: InputMaybe<OrderBy>;
  social_media_id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type CompaniesStddevSampFields = {
  __typename?: "companies_stddev_samp_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  founding_year?: Maybe<Scalars["Float"]["output"]>;
  scrape_rating?: Maybe<Scalars["Float"]["output"]>;
  social_media_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "companies" */
export type CompaniesStddevSampOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  founding_year?: InputMaybe<OrderBy>;
  scrape_rating?: InputMaybe<OrderBy>;
  social_media_id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "companies" */
export type CompaniesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CompaniesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CompaniesStreamCursorValueInput = {
  category?: InputMaybe<Scalars["String"]["input"]>;
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  founding_year?: InputMaybe<Scalars["smallint"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_english?: InputMaybe<Scalars["Boolean"]["input"]>;
  is_government?: InputMaybe<Scalars["Boolean"]["input"]>;
  keywords?: InputMaybe<Scalars["jsonb"]["input"]>;
  logo_url?: InputMaybe<Scalars["String"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  scrape_frequency?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  scrape_rating?: InputMaybe<Scalars["smallint"]["input"]>;
  scraped_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  social_media_id?: InputMaybe<Scalars["Int"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type CompaniesSumFields = {
  __typename?: "companies_sum_fields";
  category_id?: Maybe<Scalars["bigint"]["output"]>;
  failed_count?: Maybe<Scalars["smallint"]["output"]>;
  founding_year?: Maybe<Scalars["smallint"]["output"]>;
  scrape_rating?: Maybe<Scalars["smallint"]["output"]>;
  social_media_id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "companies" */
export type CompaniesSumOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  founding_year?: InputMaybe<OrderBy>;
  scrape_rating?: InputMaybe<OrderBy>;
  social_media_id?: InputMaybe<OrderBy>;
};

/** update columns of table "companies" */
export enum CompaniesUpdateColumn {
  /** column name */
  CATEGORY = "category",
  /** column name */
  CATEGORY_ID = "category_id",
  /** column name */
  CONTENT_STATUS = "content_status",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  FAILED_COUNT = "failed_count",
  /** column name */
  FOUNDING_YEAR = "founding_year",
  /** column name */
  ID = "id",
  /** column name */
  IS_ENGLISH = "is_english",
  /** column name */
  IS_GOVERNMENT = "is_government",
  /** column name */
  KEYWORDS = "keywords",
  /** column name */
  LOGO_URL = "logo_url",
  /** column name */
  NAME = "name",
  /** column name */
  SCRAPE_FREQUENCY = "scrape_frequency",
  /** column name */
  SCRAPE_RATING = "scrape_rating",
  /** column name */
  SCRAPED_AT = "scraped_at",
  /** column name */
  SOCIAL_MEDIA_ID = "social_media_id",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
}

export type CompaniesUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<CompaniesAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<CompaniesDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<CompaniesDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<CompaniesDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<CompaniesIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<CompaniesPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CompaniesSetInput>;
  /** filter the rows which have to be updated */
  where: CompaniesBoolExp;
};

/** aggregate var_pop on columns */
export type CompaniesVarPopFields = {
  __typename?: "companies_var_pop_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  founding_year?: Maybe<Scalars["Float"]["output"]>;
  scrape_rating?: Maybe<Scalars["Float"]["output"]>;
  social_media_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "companies" */
export type CompaniesVarPopOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  founding_year?: InputMaybe<OrderBy>;
  scrape_rating?: InputMaybe<OrderBy>;
  social_media_id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type CompaniesVarSampFields = {
  __typename?: "companies_var_samp_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  founding_year?: Maybe<Scalars["Float"]["output"]>;
  scrape_rating?: Maybe<Scalars["Float"]["output"]>;
  social_media_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "companies" */
export type CompaniesVarSampOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  founding_year?: InputMaybe<OrderBy>;
  scrape_rating?: InputMaybe<OrderBy>;
  social_media_id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type CompaniesVarianceFields = {
  __typename?: "companies_variance_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  founding_year?: Maybe<Scalars["Float"]["output"]>;
  scrape_rating?: Maybe<Scalars["Float"]["output"]>;
  social_media_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "companies" */
export type CompaniesVarianceOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  founding_year?: InputMaybe<OrderBy>;
  scrape_rating?: InputMaybe<OrderBy>;
  social_media_id?: InputMaybe<OrderBy>;
};

/** columns and relationships of "company_contacts" */
export type CompanyContacts = {
  __typename?: "company_contacts";
  /** An object relationship */
  company?: Maybe<Companies>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  /** An object relationship */
  contact: Contacts;
  contact_id: Scalars["Int"]["output"];
  created_at: Scalars["timestamptz"]["output"];
  id: Scalars["Int"]["output"];
  updated_at: Scalars["timestamptz"]["output"];
};

/** aggregated selection of "company_contacts" */
export type CompanyContactsAggregate = {
  __typename?: "company_contacts_aggregate";
  aggregate?: Maybe<CompanyContactsAggregateFields>;
  nodes: Array<CompanyContacts>;
};

export type CompanyContactsAggregateBoolExp = {
  count?: InputMaybe<CompanyContactsAggregateBoolExpCount>;
};

export type CompanyContactsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<CompanyContactsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CompanyContactsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "company_contacts" */
export type CompanyContactsAggregateFields = {
  __typename?: "company_contacts_aggregate_fields";
  avg?: Maybe<CompanyContactsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<CompanyContactsMaxFields>;
  min?: Maybe<CompanyContactsMinFields>;
  stddev?: Maybe<CompanyContactsStddevFields>;
  stddev_pop?: Maybe<CompanyContactsStddevPopFields>;
  stddev_samp?: Maybe<CompanyContactsStddevSampFields>;
  sum?: Maybe<CompanyContactsSumFields>;
  var_pop?: Maybe<CompanyContactsVarPopFields>;
  var_samp?: Maybe<CompanyContactsVarSampFields>;
  variance?: Maybe<CompanyContactsVarianceFields>;
};

/** aggregate fields of "company_contacts" */
export type CompanyContactsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CompanyContactsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "company_contacts" */
export type CompanyContactsAggregateOrderBy = {
  avg?: InputMaybe<CompanyContactsAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<CompanyContactsMaxOrderBy>;
  min?: InputMaybe<CompanyContactsMinOrderBy>;
  stddev?: InputMaybe<CompanyContactsStddevOrderBy>;
  stddev_pop?: InputMaybe<CompanyContactsStddevPopOrderBy>;
  stddev_samp?: InputMaybe<CompanyContactsStddevSampOrderBy>;
  sum?: InputMaybe<CompanyContactsSumOrderBy>;
  var_pop?: InputMaybe<CompanyContactsVarPopOrderBy>;
  var_samp?: InputMaybe<CompanyContactsVarSampOrderBy>;
  variance?: InputMaybe<CompanyContactsVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "company_contacts" */
export type CompanyContactsArrRelInsertInput = {
  data: Array<CompanyContactsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<CompanyContactsOnConflict>;
};

/** aggregate avg on columns */
export type CompanyContactsAvgFields = {
  __typename?: "company_contacts_avg_fields";
  contact_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "company_contacts" */
export type CompanyContactsAvgOrderBy = {
  contact_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "company_contacts". All fields are combined with a logical 'AND'. */
export type CompanyContactsBoolExp = {
  _and?: InputMaybe<Array<CompanyContactsBoolExp>>;
  _not?: InputMaybe<CompanyContactsBoolExp>;
  _or?: InputMaybe<Array<CompanyContactsBoolExp>>;
  company?: InputMaybe<CompaniesBoolExp>;
  company_id?: InputMaybe<UuidComparisonExp>;
  contact?: InputMaybe<ContactsBoolExp>;
  contact_id?: InputMaybe<IntComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
};

/** unique or primary key constraints on table "company_contacts" */
export enum CompanyContactsConstraint {
  /** unique or primary key constraint on columns "id" */
  COMPANY_CONTACTS_PKEY = "company_contacts_pkey",
}

/** input type for incrementing numeric columns in table "company_contacts" */
export type CompanyContactsIncInput = {
  contact_id?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "company_contacts" */
export type CompanyContactsInsertInput = {
  company?: InputMaybe<CompaniesObjRelInsertInput>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  contact?: InputMaybe<ContactsObjRelInsertInput>;
  contact_id?: InputMaybe<Scalars["Int"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate max on columns */
export type CompanyContactsMaxFields = {
  __typename?: "company_contacts_max_fields";
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  contact_id?: Maybe<Scalars["Int"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** order by max() on columns of table "company_contacts" */
export type CompanyContactsMaxOrderBy = {
  company_id?: InputMaybe<OrderBy>;
  contact_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type CompanyContactsMinFields = {
  __typename?: "company_contacts_min_fields";
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  contact_id?: Maybe<Scalars["Int"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** order by min() on columns of table "company_contacts" */
export type CompanyContactsMinOrderBy = {
  company_id?: InputMaybe<OrderBy>;
  contact_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "company_contacts" */
export type CompanyContactsMutationResponse = {
  __typename?: "company_contacts_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<CompanyContacts>;
};

/** on_conflict condition type for table "company_contacts" */
export type CompanyContactsOnConflict = {
  constraint: CompanyContactsConstraint;
  update_columns?: Array<CompanyContactsUpdateColumn>;
  where?: InputMaybe<CompanyContactsBoolExp>;
};

/** Ordering options when selecting data from "company_contacts". */
export type CompanyContactsOrderBy = {
  company?: InputMaybe<CompaniesOrderBy>;
  company_id?: InputMaybe<OrderBy>;
  contact?: InputMaybe<ContactsOrderBy>;
  contact_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: company_contacts */
export type CompanyContactsPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "company_contacts" */
export enum CompanyContactsSelectColumn {
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CONTACT_ID = "contact_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  UPDATED_AT = "updated_at",
}

/** input type for updating data in table "company_contacts" */
export type CompanyContactsSetInput = {
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  contact_id?: InputMaybe<Scalars["Int"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate stddev on columns */
export type CompanyContactsStddevFields = {
  __typename?: "company_contacts_stddev_fields";
  contact_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "company_contacts" */
export type CompanyContactsStddevOrderBy = {
  contact_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type CompanyContactsStddevPopFields = {
  __typename?: "company_contacts_stddev_pop_fields";
  contact_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "company_contacts" */
export type CompanyContactsStddevPopOrderBy = {
  contact_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type CompanyContactsStddevSampFields = {
  __typename?: "company_contacts_stddev_samp_fields";
  contact_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "company_contacts" */
export type CompanyContactsStddevSampOrderBy = {
  contact_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "company_contacts" */
export type CompanyContactsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CompanyContactsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CompanyContactsStreamCursorValueInput = {
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  contact_id?: InputMaybe<Scalars["Int"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate sum on columns */
export type CompanyContactsSumFields = {
  __typename?: "company_contacts_sum_fields";
  contact_id?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "company_contacts" */
export type CompanyContactsSumOrderBy = {
  contact_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** update columns of table "company_contacts" */
export enum CompanyContactsUpdateColumn {
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CONTACT_ID = "contact_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  UPDATED_AT = "updated_at",
}

export type CompanyContactsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<CompanyContactsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CompanyContactsSetInput>;
  /** filter the rows which have to be updated */
  where: CompanyContactsBoolExp;
};

/** aggregate var_pop on columns */
export type CompanyContactsVarPopFields = {
  __typename?: "company_contacts_var_pop_fields";
  contact_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "company_contacts" */
export type CompanyContactsVarPopOrderBy = {
  contact_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type CompanyContactsVarSampFields = {
  __typename?: "company_contacts_var_samp_fields";
  contact_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "company_contacts" */
export type CompanyContactsVarSampOrderBy = {
  contact_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type CompanyContactsVarianceFields = {
  __typename?: "company_contacts_variance_fields";
  contact_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "company_contacts" */
export type CompanyContactsVarianceOrderBy = {
  contact_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** columns and relationships of "company_employees" */
export type CompanyEmployees = {
  __typename?: "company_employees";
  access_level: Scalars["access_level"]["output"];
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  end_date?: Maybe<Scalars["timestamptz"]["output"]>;
  id: Scalars["uuid"]["output"];
  job_description?: Maybe<Scalars["String"]["output"]>;
  role: Scalars["String"]["output"];
  start_date?: Maybe<Scalars["timestamptz"]["output"]>;
  status?: Maybe<Scalars["Boolean"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id: Scalars["uuid"]["output"];
  /** An object relationship */
  user_profile: UserProfiles;
};

/** aggregated selection of "company_employees" */
export type CompanyEmployeesAggregate = {
  __typename?: "company_employees_aggregate";
  aggregate?: Maybe<CompanyEmployeesAggregateFields>;
  nodes: Array<CompanyEmployees>;
};

export type CompanyEmployeesAggregateBoolExp = {
  bool_and?: InputMaybe<CompanyEmployeesAggregateBoolExpBoolAnd>;
  bool_or?: InputMaybe<CompanyEmployeesAggregateBoolExpBoolOr>;
  count?: InputMaybe<CompanyEmployeesAggregateBoolExpCount>;
};

export type CompanyEmployeesAggregateBoolExpBoolAnd = {
  arguments: CompanyEmployeesSelectColumnCompanyEmployeesAggregateBoolExpBoolAndArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CompanyEmployeesBoolExp>;
  predicate: BooleanComparisonExp;
};

export type CompanyEmployeesAggregateBoolExpBoolOr = {
  arguments: CompanyEmployeesSelectColumnCompanyEmployeesAggregateBoolExpBoolOrArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CompanyEmployeesBoolExp>;
  predicate: BooleanComparisonExp;
};

export type CompanyEmployeesAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<CompanyEmployeesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CompanyEmployeesBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "company_employees" */
export type CompanyEmployeesAggregateFields = {
  __typename?: "company_employees_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<CompanyEmployeesMaxFields>;
  min?: Maybe<CompanyEmployeesMinFields>;
};

/** aggregate fields of "company_employees" */
export type CompanyEmployeesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CompanyEmployeesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "company_employees" */
export type CompanyEmployeesAggregateOrderBy = {
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<CompanyEmployeesMaxOrderBy>;
  min?: InputMaybe<CompanyEmployeesMinOrderBy>;
};

/** input type for inserting array relation for remote table "company_employees" */
export type CompanyEmployeesArrRelInsertInput = {
  data: Array<CompanyEmployeesInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<CompanyEmployeesOnConflict>;
};

/** Boolean expression to filter rows from the table "company_employees". All fields are combined with a logical 'AND'. */
export type CompanyEmployeesBoolExp = {
  _and?: InputMaybe<Array<CompanyEmployeesBoolExp>>;
  _not?: InputMaybe<CompanyEmployeesBoolExp>;
  _or?: InputMaybe<Array<CompanyEmployeesBoolExp>>;
  access_level?: InputMaybe<AccessLevelComparisonExp>;
  company_id?: InputMaybe<UuidComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  end_date?: InputMaybe<TimestamptzComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  job_description?: InputMaybe<StringComparisonExp>;
  role?: InputMaybe<StringComparisonExp>;
  start_date?: InputMaybe<TimestamptzComparisonExp>;
  status?: InputMaybe<BooleanComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
  user_profile?: InputMaybe<UserProfilesBoolExp>;
};

/** unique or primary key constraints on table "company_employees" */
export enum CompanyEmployeesConstraint {
  /** unique or primary key constraint on columns "id" */
  COMPANY_EMPLOYEES_PKEY = "company_employees_pkey",
}

/** input type for inserting data into table "company_employees" */
export type CompanyEmployeesInsertInput = {
  access_level?: InputMaybe<Scalars["access_level"]["input"]>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  end_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  job_description?: InputMaybe<Scalars["String"]["input"]>;
  role?: InputMaybe<Scalars["String"]["input"]>;
  start_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  status?: InputMaybe<Scalars["Boolean"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
};

/** aggregate max on columns */
export type CompanyEmployeesMaxFields = {
  __typename?: "company_employees_max_fields";
  access_level?: Maybe<Scalars["access_level"]["output"]>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  end_date?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  job_description?: Maybe<Scalars["String"]["output"]>;
  role?: Maybe<Scalars["String"]["output"]>;
  start_date?: Maybe<Scalars["timestamptz"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by max() on columns of table "company_employees" */
export type CompanyEmployeesMaxOrderBy = {
  access_level?: InputMaybe<OrderBy>;
  company_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  end_date?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  job_description?: InputMaybe<OrderBy>;
  role?: InputMaybe<OrderBy>;
  start_date?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type CompanyEmployeesMinFields = {
  __typename?: "company_employees_min_fields";
  access_level?: Maybe<Scalars["access_level"]["output"]>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  end_date?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  job_description?: Maybe<Scalars["String"]["output"]>;
  role?: Maybe<Scalars["String"]["output"]>;
  start_date?: Maybe<Scalars["timestamptz"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by min() on columns of table "company_employees" */
export type CompanyEmployeesMinOrderBy = {
  access_level?: InputMaybe<OrderBy>;
  company_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  end_date?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  job_description?: InputMaybe<OrderBy>;
  role?: InputMaybe<OrderBy>;
  start_date?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "company_employees" */
export type CompanyEmployeesMutationResponse = {
  __typename?: "company_employees_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<CompanyEmployees>;
};

/** on_conflict condition type for table "company_employees" */
export type CompanyEmployeesOnConflict = {
  constraint: CompanyEmployeesConstraint;
  update_columns?: Array<CompanyEmployeesUpdateColumn>;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
};

/** Ordering options when selecting data from "company_employees". */
export type CompanyEmployeesOrderBy = {
  access_level?: InputMaybe<OrderBy>;
  company_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  end_date?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  job_description?: InputMaybe<OrderBy>;
  role?: InputMaybe<OrderBy>;
  start_date?: InputMaybe<OrderBy>;
  status?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  user_profile?: InputMaybe<UserProfilesOrderBy>;
};

/** primary key columns input for table: company_employees */
export type CompanyEmployeesPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "company_employees" */
export enum CompanyEmployeesSelectColumn {
  /** column name */
  ACCESS_LEVEL = "access_level",
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  END_DATE = "end_date",
  /** column name */
  ID = "id",
  /** column name */
  JOB_DESCRIPTION = "job_description",
  /** column name */
  ROLE = "role",
  /** column name */
  START_DATE = "start_date",
  /** column name */
  STATUS = "status",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

/** select "company_employees_aggregate_bool_exp_bool_and_arguments_columns" columns of table "company_employees" */
export enum CompanyEmployeesSelectColumnCompanyEmployeesAggregateBoolExpBoolAndArgumentsColumns {
  /** column name */
  STATUS = "status",
}

/** select "company_employees_aggregate_bool_exp_bool_or_arguments_columns" columns of table "company_employees" */
export enum CompanyEmployeesSelectColumnCompanyEmployeesAggregateBoolExpBoolOrArgumentsColumns {
  /** column name */
  STATUS = "status",
}

/** input type for updating data in table "company_employees" */
export type CompanyEmployeesSetInput = {
  access_level?: InputMaybe<Scalars["access_level"]["input"]>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  end_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  job_description?: InputMaybe<Scalars["String"]["input"]>;
  role?: InputMaybe<Scalars["String"]["input"]>;
  start_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  status?: InputMaybe<Scalars["Boolean"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** Streaming cursor of the table "company_employees" */
export type CompanyEmployeesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CompanyEmployeesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CompanyEmployeesStreamCursorValueInput = {
  access_level?: InputMaybe<Scalars["access_level"]["input"]>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  end_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  job_description?: InputMaybe<Scalars["String"]["input"]>;
  role?: InputMaybe<Scalars["String"]["input"]>;
  start_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  status?: InputMaybe<Scalars["Boolean"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** update columns of table "company_employees" */
export enum CompanyEmployeesUpdateColumn {
  /** column name */
  ACCESS_LEVEL = "access_level",
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  END_DATE = "end_date",
  /** column name */
  ID = "id",
  /** column name */
  JOB_DESCRIPTION = "job_description",
  /** column name */
  ROLE = "role",
  /** column name */
  START_DATE = "start_date",
  /** column name */
  STATUS = "status",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

export type CompanyEmployeesUpdates = {
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CompanyEmployeesSetInput>;
  /** filter the rows which have to be updated */
  where: CompanyEmployeesBoolExp;
};

/** columns and relationships of "company_extras" */
export type CompanyExtras = {
  __typename?: "company_extras";
  body?: Maybe<Scalars["String"]["output"]>;
  category: Scalars["String"]["output"];
  /** An object relationship */
  company?: Maybe<Companies>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at: Scalars["timestamptz"]["output"];
  found_count?: Maybe<Scalars["Int"]["output"]>;
  id: Scalars["Int"]["output"];
  level: Scalars["smallint"]["output"];
  review?: Maybe<Scalars["jsonb"]["output"]>;
  success?: Maybe<Scalars["Boolean"]["output"]>;
  updated_at: Scalars["timestamptz"]["output"];
  url: Scalars["String"]["output"];
};

/** columns and relationships of "company_extras" */
export type CompanyExtrasReviewArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "company_extras" */
export type CompanyExtrasAggregate = {
  __typename?: "company_extras_aggregate";
  aggregate?: Maybe<CompanyExtrasAggregateFields>;
  nodes: Array<CompanyExtras>;
};

export type CompanyExtrasAggregateBoolExp = {
  bool_and?: InputMaybe<CompanyExtrasAggregateBoolExpBoolAnd>;
  bool_or?: InputMaybe<CompanyExtrasAggregateBoolExpBoolOr>;
  count?: InputMaybe<CompanyExtrasAggregateBoolExpCount>;
};

export type CompanyExtrasAggregateBoolExpBoolAnd = {
  arguments: CompanyExtrasSelectColumnCompanyExtrasAggregateBoolExpBoolAndArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CompanyExtrasBoolExp>;
  predicate: BooleanComparisonExp;
};

export type CompanyExtrasAggregateBoolExpBoolOr = {
  arguments: CompanyExtrasSelectColumnCompanyExtrasAggregateBoolExpBoolOrArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CompanyExtrasBoolExp>;
  predicate: BooleanComparisonExp;
};

export type CompanyExtrasAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<CompanyExtrasSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CompanyExtrasBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "company_extras" */
export type CompanyExtrasAggregateFields = {
  __typename?: "company_extras_aggregate_fields";
  avg?: Maybe<CompanyExtrasAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<CompanyExtrasMaxFields>;
  min?: Maybe<CompanyExtrasMinFields>;
  stddev?: Maybe<CompanyExtrasStddevFields>;
  stddev_pop?: Maybe<CompanyExtrasStddevPopFields>;
  stddev_samp?: Maybe<CompanyExtrasStddevSampFields>;
  sum?: Maybe<CompanyExtrasSumFields>;
  var_pop?: Maybe<CompanyExtrasVarPopFields>;
  var_samp?: Maybe<CompanyExtrasVarSampFields>;
  variance?: Maybe<CompanyExtrasVarianceFields>;
};

/** aggregate fields of "company_extras" */
export type CompanyExtrasAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CompanyExtrasSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "company_extras" */
export type CompanyExtrasAggregateOrderBy = {
  avg?: InputMaybe<CompanyExtrasAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<CompanyExtrasMaxOrderBy>;
  min?: InputMaybe<CompanyExtrasMinOrderBy>;
  stddev?: InputMaybe<CompanyExtrasStddevOrderBy>;
  stddev_pop?: InputMaybe<CompanyExtrasStddevPopOrderBy>;
  stddev_samp?: InputMaybe<CompanyExtrasStddevSampOrderBy>;
  sum?: InputMaybe<CompanyExtrasSumOrderBy>;
  var_pop?: InputMaybe<CompanyExtrasVarPopOrderBy>;
  var_samp?: InputMaybe<CompanyExtrasVarSampOrderBy>;
  variance?: InputMaybe<CompanyExtrasVarianceOrderBy>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type CompanyExtrasAppendInput = {
  review?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** input type for inserting array relation for remote table "company_extras" */
export type CompanyExtrasArrRelInsertInput = {
  data: Array<CompanyExtrasInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<CompanyExtrasOnConflict>;
};

/** aggregate avg on columns */
export type CompanyExtrasAvgFields = {
  __typename?: "company_extras_avg_fields";
  found_count?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  level?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "company_extras" */
export type CompanyExtrasAvgOrderBy = {
  found_count?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  level?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "company_extras". All fields are combined with a logical 'AND'. */
export type CompanyExtrasBoolExp = {
  _and?: InputMaybe<Array<CompanyExtrasBoolExp>>;
  _not?: InputMaybe<CompanyExtrasBoolExp>;
  _or?: InputMaybe<Array<CompanyExtrasBoolExp>>;
  body?: InputMaybe<StringComparisonExp>;
  category?: InputMaybe<StringComparisonExp>;
  company?: InputMaybe<CompaniesBoolExp>;
  company_id?: InputMaybe<UuidComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  found_count?: InputMaybe<IntComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  level?: InputMaybe<SmallintComparisonExp>;
  review?: InputMaybe<JsonbComparisonExp>;
  success?: InputMaybe<BooleanComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  url?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "company_extras" */
export enum CompanyExtrasConstraint {
  /** unique or primary key constraint on columns "id" */
  COMPANY_EXTRAS_PKEY = "company_extras_pkey",
  /** unique or primary key constraint on columns "url" */
  IDX_CE_UNIQUE_URL = "idx_ce_unique_url",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type CompanyExtrasDeleteAtPathInput = {
  review?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type CompanyExtrasDeleteElemInput = {
  review?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type CompanyExtrasDeleteKeyInput = {
  review?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for incrementing numeric columns in table "company_extras" */
export type CompanyExtrasIncInput = {
  found_count?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  level?: InputMaybe<Scalars["smallint"]["input"]>;
};

/** input type for inserting data into table "company_extras" */
export type CompanyExtrasInsertInput = {
  body?: InputMaybe<Scalars["String"]["input"]>;
  category?: InputMaybe<Scalars["String"]["input"]>;
  company?: InputMaybe<CompaniesObjRelInsertInput>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  found_count?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  level?: InputMaybe<Scalars["smallint"]["input"]>;
  review?: InputMaybe<Scalars["jsonb"]["input"]>;
  success?: InputMaybe<Scalars["Boolean"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type CompanyExtrasMaxFields = {
  __typename?: "company_extras_max_fields";
  body?: Maybe<Scalars["String"]["output"]>;
  category?: Maybe<Scalars["String"]["output"]>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  found_count?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  level?: Maybe<Scalars["smallint"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** order by max() on columns of table "company_extras" */
export type CompanyExtrasMaxOrderBy = {
  body?: InputMaybe<OrderBy>;
  category?: InputMaybe<OrderBy>;
  company_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  found_count?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  level?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type CompanyExtrasMinFields = {
  __typename?: "company_extras_min_fields";
  body?: Maybe<Scalars["String"]["output"]>;
  category?: Maybe<Scalars["String"]["output"]>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  found_count?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  level?: Maybe<Scalars["smallint"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** order by min() on columns of table "company_extras" */
export type CompanyExtrasMinOrderBy = {
  body?: InputMaybe<OrderBy>;
  category?: InputMaybe<OrderBy>;
  company_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  found_count?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  level?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "company_extras" */
export type CompanyExtrasMutationResponse = {
  __typename?: "company_extras_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<CompanyExtras>;
};

/** on_conflict condition type for table "company_extras" */
export type CompanyExtrasOnConflict = {
  constraint: CompanyExtrasConstraint;
  update_columns?: Array<CompanyExtrasUpdateColumn>;
  where?: InputMaybe<CompanyExtrasBoolExp>;
};

/** Ordering options when selecting data from "company_extras". */
export type CompanyExtrasOrderBy = {
  body?: InputMaybe<OrderBy>;
  category?: InputMaybe<OrderBy>;
  company?: InputMaybe<CompaniesOrderBy>;
  company_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  found_count?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  level?: InputMaybe<OrderBy>;
  review?: InputMaybe<OrderBy>;
  success?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: company_extras */
export type CompanyExtrasPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type CompanyExtrasPrependInput = {
  review?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "company_extras" */
export enum CompanyExtrasSelectColumn {
  /** column name */
  BODY = "body",
  /** column name */
  CATEGORY = "category",
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FOUND_COUNT = "found_count",
  /** column name */
  ID = "id",
  /** column name */
  LEVEL = "level",
  /** column name */
  REVIEW = "review",
  /** column name */
  SUCCESS = "success",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
}

/** select "company_extras_aggregate_bool_exp_bool_and_arguments_columns" columns of table "company_extras" */
export enum CompanyExtrasSelectColumnCompanyExtrasAggregateBoolExpBoolAndArgumentsColumns {
  /** column name */
  SUCCESS = "success",
}

/** select "company_extras_aggregate_bool_exp_bool_or_arguments_columns" columns of table "company_extras" */
export enum CompanyExtrasSelectColumnCompanyExtrasAggregateBoolExpBoolOrArgumentsColumns {
  /** column name */
  SUCCESS = "success",
}

/** input type for updating data in table "company_extras" */
export type CompanyExtrasSetInput = {
  body?: InputMaybe<Scalars["String"]["input"]>;
  category?: InputMaybe<Scalars["String"]["input"]>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  found_count?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  level?: InputMaybe<Scalars["smallint"]["input"]>;
  review?: InputMaybe<Scalars["jsonb"]["input"]>;
  success?: InputMaybe<Scalars["Boolean"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type CompanyExtrasStddevFields = {
  __typename?: "company_extras_stddev_fields";
  found_count?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  level?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "company_extras" */
export type CompanyExtrasStddevOrderBy = {
  found_count?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  level?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type CompanyExtrasStddevPopFields = {
  __typename?: "company_extras_stddev_pop_fields";
  found_count?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  level?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "company_extras" */
export type CompanyExtrasStddevPopOrderBy = {
  found_count?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  level?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type CompanyExtrasStddevSampFields = {
  __typename?: "company_extras_stddev_samp_fields";
  found_count?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  level?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "company_extras" */
export type CompanyExtrasStddevSampOrderBy = {
  found_count?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  level?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "company_extras" */
export type CompanyExtrasStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CompanyExtrasStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CompanyExtrasStreamCursorValueInput = {
  body?: InputMaybe<Scalars["String"]["input"]>;
  category?: InputMaybe<Scalars["String"]["input"]>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  found_count?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  level?: InputMaybe<Scalars["smallint"]["input"]>;
  review?: InputMaybe<Scalars["jsonb"]["input"]>;
  success?: InputMaybe<Scalars["Boolean"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type CompanyExtrasSumFields = {
  __typename?: "company_extras_sum_fields";
  found_count?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  level?: Maybe<Scalars["smallint"]["output"]>;
};

/** order by sum() on columns of table "company_extras" */
export type CompanyExtrasSumOrderBy = {
  found_count?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  level?: InputMaybe<OrderBy>;
};

/** update columns of table "company_extras" */
export enum CompanyExtrasUpdateColumn {
  /** column name */
  BODY = "body",
  /** column name */
  CATEGORY = "category",
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FOUND_COUNT = "found_count",
  /** column name */
  ID = "id",
  /** column name */
  LEVEL = "level",
  /** column name */
  REVIEW = "review",
  /** column name */
  SUCCESS = "success",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
}

export type CompanyExtrasUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<CompanyExtrasAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<CompanyExtrasDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<CompanyExtrasDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<CompanyExtrasDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<CompanyExtrasIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<CompanyExtrasPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CompanyExtrasSetInput>;
  /** filter the rows which have to be updated */
  where: CompanyExtrasBoolExp;
};

/** aggregate var_pop on columns */
export type CompanyExtrasVarPopFields = {
  __typename?: "company_extras_var_pop_fields";
  found_count?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  level?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "company_extras" */
export type CompanyExtrasVarPopOrderBy = {
  found_count?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  level?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type CompanyExtrasVarSampFields = {
  __typename?: "company_extras_var_samp_fields";
  found_count?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  level?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "company_extras" */
export type CompanyExtrasVarSampOrderBy = {
  found_count?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  level?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type CompanyExtrasVarianceFields = {
  __typename?: "company_extras_variance_fields";
  found_count?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  level?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "company_extras" */
export type CompanyExtrasVarianceOrderBy = {
  found_count?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  level?: InputMaybe<OrderBy>;
};

/** columns and relationships of "company_metrics" */
export type CompanyMetrics = {
  __typename?: "company_metrics";
  company_id: Scalars["uuid"]["output"];
  crawl_id: Scalars["uuid"]["output"];
  id: Scalars["bigint"]["output"];
  /** An object relationship */
  metric_definition?: Maybe<MetricDefinitions>;
  metric_id?: Maybe<Scalars["Int"]["output"]>;
  timestamp: Scalars["timestamptz"]["output"];
  value: Scalars["jsonb"]["output"];
};

/** columns and relationships of "company_metrics" */
export type CompanyMetricsValueArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "company_metrics" */
export type CompanyMetricsAggregate = {
  __typename?: "company_metrics_aggregate";
  aggregate?: Maybe<CompanyMetricsAggregateFields>;
  nodes: Array<CompanyMetrics>;
};

export type CompanyMetricsAggregateBoolExp = {
  count?: InputMaybe<CompanyMetricsAggregateBoolExpCount>;
};

export type CompanyMetricsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<CompanyMetricsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CompanyMetricsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "company_metrics" */
export type CompanyMetricsAggregateFields = {
  __typename?: "company_metrics_aggregate_fields";
  avg?: Maybe<CompanyMetricsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<CompanyMetricsMaxFields>;
  min?: Maybe<CompanyMetricsMinFields>;
  stddev?: Maybe<CompanyMetricsStddevFields>;
  stddev_pop?: Maybe<CompanyMetricsStddevPopFields>;
  stddev_samp?: Maybe<CompanyMetricsStddevSampFields>;
  sum?: Maybe<CompanyMetricsSumFields>;
  var_pop?: Maybe<CompanyMetricsVarPopFields>;
  var_samp?: Maybe<CompanyMetricsVarSampFields>;
  variance?: Maybe<CompanyMetricsVarianceFields>;
};

/** aggregate fields of "company_metrics" */
export type CompanyMetricsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CompanyMetricsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "company_metrics" */
export type CompanyMetricsAggregateOrderBy = {
  avg?: InputMaybe<CompanyMetricsAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<CompanyMetricsMaxOrderBy>;
  min?: InputMaybe<CompanyMetricsMinOrderBy>;
  stddev?: InputMaybe<CompanyMetricsStddevOrderBy>;
  stddev_pop?: InputMaybe<CompanyMetricsStddevPopOrderBy>;
  stddev_samp?: InputMaybe<CompanyMetricsStddevSampOrderBy>;
  sum?: InputMaybe<CompanyMetricsSumOrderBy>;
  var_pop?: InputMaybe<CompanyMetricsVarPopOrderBy>;
  var_samp?: InputMaybe<CompanyMetricsVarSampOrderBy>;
  variance?: InputMaybe<CompanyMetricsVarianceOrderBy>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type CompanyMetricsAppendInput = {
  value?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** input type for inserting array relation for remote table "company_metrics" */
export type CompanyMetricsArrRelInsertInput = {
  data: Array<CompanyMetricsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<CompanyMetricsOnConflict>;
};

/** aggregate avg on columns */
export type CompanyMetricsAvgFields = {
  __typename?: "company_metrics_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  metric_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "company_metrics" */
export type CompanyMetricsAvgOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "company_metrics". All fields are combined with a logical 'AND'. */
export type CompanyMetricsBoolExp = {
  _and?: InputMaybe<Array<CompanyMetricsBoolExp>>;
  _not?: InputMaybe<CompanyMetricsBoolExp>;
  _or?: InputMaybe<Array<CompanyMetricsBoolExp>>;
  company_id?: InputMaybe<UuidComparisonExp>;
  crawl_id?: InputMaybe<UuidComparisonExp>;
  id?: InputMaybe<BigintComparisonExp>;
  metric_definition?: InputMaybe<MetricDefinitionsBoolExp>;
  metric_id?: InputMaybe<IntComparisonExp>;
  timestamp?: InputMaybe<TimestamptzComparisonExp>;
  value?: InputMaybe<JsonbComparisonExp>;
};

/** unique or primary key constraints on table "company_metrics" */
export enum CompanyMetricsConstraint {
  /** unique or primary key constraint on columns "id" */
  COMPANY_METRICS_PKEY = "company_metrics_pkey",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type CompanyMetricsDeleteAtPathInput = {
  value?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type CompanyMetricsDeleteElemInput = {
  value?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type CompanyMetricsDeleteKeyInput = {
  value?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for incrementing numeric columns in table "company_metrics" */
export type CompanyMetricsIncInput = {
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  metric_id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "company_metrics" */
export type CompanyMetricsInsertInput = {
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  crawl_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  metric_definition?: InputMaybe<MetricDefinitionsObjRelInsertInput>;
  metric_id?: InputMaybe<Scalars["Int"]["input"]>;
  timestamp?: InputMaybe<Scalars["timestamptz"]["input"]>;
  value?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** aggregate max on columns */
export type CompanyMetricsMaxFields = {
  __typename?: "company_metrics_max_fields";
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  crawl_id?: Maybe<Scalars["uuid"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  metric_id?: Maybe<Scalars["Int"]["output"]>;
  timestamp?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** order by max() on columns of table "company_metrics" */
export type CompanyMetricsMaxOrderBy = {
  company_id?: InputMaybe<OrderBy>;
  crawl_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
  timestamp?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type CompanyMetricsMinFields = {
  __typename?: "company_metrics_min_fields";
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  crawl_id?: Maybe<Scalars["uuid"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  metric_id?: Maybe<Scalars["Int"]["output"]>;
  timestamp?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** order by min() on columns of table "company_metrics" */
export type CompanyMetricsMinOrderBy = {
  company_id?: InputMaybe<OrderBy>;
  crawl_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
  timestamp?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "company_metrics" */
export type CompanyMetricsMutationResponse = {
  __typename?: "company_metrics_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<CompanyMetrics>;
};

/** on_conflict condition type for table "company_metrics" */
export type CompanyMetricsOnConflict = {
  constraint: CompanyMetricsConstraint;
  update_columns?: Array<CompanyMetricsUpdateColumn>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
};

/** Ordering options when selecting data from "company_metrics". */
export type CompanyMetricsOrderBy = {
  company_id?: InputMaybe<OrderBy>;
  crawl_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  metric_definition?: InputMaybe<MetricDefinitionsOrderBy>;
  metric_id?: InputMaybe<OrderBy>;
  timestamp?: InputMaybe<OrderBy>;
  value?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: company_metrics */
export type CompanyMetricsPkColumnsInput = {
  id: Scalars["bigint"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type CompanyMetricsPrependInput = {
  value?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "company_metrics" */
export enum CompanyMetricsSelectColumn {
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CRAWL_ID = "crawl_id",
  /** column name */
  ID = "id",
  /** column name */
  METRIC_ID = "metric_id",
  /** column name */
  TIMESTAMP = "timestamp",
  /** column name */
  VALUE = "value",
}

/** input type for updating data in table "company_metrics" */
export type CompanyMetricsSetInput = {
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  crawl_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  metric_id?: InputMaybe<Scalars["Int"]["input"]>;
  timestamp?: InputMaybe<Scalars["timestamptz"]["input"]>;
  value?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** aggregate stddev on columns */
export type CompanyMetricsStddevFields = {
  __typename?: "company_metrics_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  metric_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "company_metrics" */
export type CompanyMetricsStddevOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type CompanyMetricsStddevPopFields = {
  __typename?: "company_metrics_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  metric_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "company_metrics" */
export type CompanyMetricsStddevPopOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type CompanyMetricsStddevSampFields = {
  __typename?: "company_metrics_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  metric_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "company_metrics" */
export type CompanyMetricsStddevSampOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "company_metrics" */
export type CompanyMetricsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CompanyMetricsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CompanyMetricsStreamCursorValueInput = {
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  crawl_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  metric_id?: InputMaybe<Scalars["Int"]["input"]>;
  timestamp?: InputMaybe<Scalars["timestamptz"]["input"]>;
  value?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** aggregate sum on columns */
export type CompanyMetricsSumFields = {
  __typename?: "company_metrics_sum_fields";
  id?: Maybe<Scalars["bigint"]["output"]>;
  metric_id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "company_metrics" */
export type CompanyMetricsSumOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** update columns of table "company_metrics" */
export enum CompanyMetricsUpdateColumn {
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CRAWL_ID = "crawl_id",
  /** column name */
  ID = "id",
  /** column name */
  METRIC_ID = "metric_id",
  /** column name */
  TIMESTAMP = "timestamp",
  /** column name */
  VALUE = "value",
}

export type CompanyMetricsUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<CompanyMetricsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<CompanyMetricsDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<CompanyMetricsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<CompanyMetricsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<CompanyMetricsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<CompanyMetricsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CompanyMetricsSetInput>;
  /** filter the rows which have to be updated */
  where: CompanyMetricsBoolExp;
};

/** aggregate var_pop on columns */
export type CompanyMetricsVarPopFields = {
  __typename?: "company_metrics_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  metric_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "company_metrics" */
export type CompanyMetricsVarPopOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type CompanyMetricsVarSampFields = {
  __typename?: "company_metrics_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  metric_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "company_metrics" */
export type CompanyMetricsVarSampOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type CompanyMetricsVarianceFields = {
  __typename?: "company_metrics_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  metric_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "company_metrics" */
export type CompanyMetricsVarianceOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** Boolean expression to compare columns of type "complexity_level". All fields are combined with logical 'AND'. */
export type ComplexityLevelComparisonExp = {
  _eq?: InputMaybe<Scalars["complexity_level"]["input"]>;
  _gt?: InputMaybe<Scalars["complexity_level"]["input"]>;
  _gte?: InputMaybe<Scalars["complexity_level"]["input"]>;
  _in?: InputMaybe<Array<Scalars["complexity_level"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["complexity_level"]["input"]>;
  _lte?: InputMaybe<Scalars["complexity_level"]["input"]>;
  _neq?: InputMaybe<Scalars["complexity_level"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["complexity_level"]["input"]>>;
};

/** Boolean expression to compare columns of type "contact_type". All fields are combined with logical 'AND'. */
export type ContactTypeComparisonExp = {
  _eq?: InputMaybe<Scalars["contact_type"]["input"]>;
  _gt?: InputMaybe<Scalars["contact_type"]["input"]>;
  _gte?: InputMaybe<Scalars["contact_type"]["input"]>;
  _in?: InputMaybe<Array<Scalars["contact_type"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["contact_type"]["input"]>;
  _lte?: InputMaybe<Scalars["contact_type"]["input"]>;
  _neq?: InputMaybe<Scalars["contact_type"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["contact_type"]["input"]>>;
};

/** columns and relationships of "contacts" */
export type Contacts = {
  __typename?: "contacts";
  /** An object relationship */
  company?: Maybe<Companies>;
  /** An array relationship */
  company_contacts: Array<CompanyContacts>;
  /** An aggregate relationship */
  company_contacts_aggregate: CompanyContactsAggregate;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  contact_type?: Maybe<Scalars["contact_type"]["output"]>;
  created_at?: Maybe<Scalars["timestamp"]["output"]>;
  email?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["Int"]["output"];
  is_primary?: Maybe<Scalars["Boolean"]["output"]>;
  phone?: Maybe<Scalars["String"]["output"]>;
  privacy_level?: Maybe<Scalars["privacy_level"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamp"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
  /** An object relationship */
  user_profile?: Maybe<UserProfiles>;
};

/** columns and relationships of "contacts" */
export type ContactsCompanyContactsArgs = {
  distinct_on?: InputMaybe<Array<CompanyContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyContactsOrderBy>>;
  where?: InputMaybe<CompanyContactsBoolExp>;
};

/** columns and relationships of "contacts" */
export type ContactsCompanyContactsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompanyContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyContactsOrderBy>>;
  where?: InputMaybe<CompanyContactsBoolExp>;
};

/** aggregated selection of "contacts" */
export type ContactsAggregate = {
  __typename?: "contacts_aggregate";
  aggregate?: Maybe<ContactsAggregateFields>;
  nodes: Array<Contacts>;
};

export type ContactsAggregateBoolExp = {
  bool_and?: InputMaybe<ContactsAggregateBoolExpBoolAnd>;
  bool_or?: InputMaybe<ContactsAggregateBoolExpBoolOr>;
  count?: InputMaybe<ContactsAggregateBoolExpCount>;
};

export type ContactsAggregateBoolExpBoolAnd = {
  arguments: ContactsSelectColumnContactsAggregateBoolExpBoolAndArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ContactsBoolExp>;
  predicate: BooleanComparisonExp;
};

export type ContactsAggregateBoolExpBoolOr = {
  arguments: ContactsSelectColumnContactsAggregateBoolExpBoolOrArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ContactsBoolExp>;
  predicate: BooleanComparisonExp;
};

export type ContactsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<ContactsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ContactsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "contacts" */
export type ContactsAggregateFields = {
  __typename?: "contacts_aggregate_fields";
  avg?: Maybe<ContactsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ContactsMaxFields>;
  min?: Maybe<ContactsMinFields>;
  stddev?: Maybe<ContactsStddevFields>;
  stddev_pop?: Maybe<ContactsStddevPopFields>;
  stddev_samp?: Maybe<ContactsStddevSampFields>;
  sum?: Maybe<ContactsSumFields>;
  var_pop?: Maybe<ContactsVarPopFields>;
  var_samp?: Maybe<ContactsVarSampFields>;
  variance?: Maybe<ContactsVarianceFields>;
};

/** aggregate fields of "contacts" */
export type ContactsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ContactsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "contacts" */
export type ContactsAggregateOrderBy = {
  avg?: InputMaybe<ContactsAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<ContactsMaxOrderBy>;
  min?: InputMaybe<ContactsMinOrderBy>;
  stddev?: InputMaybe<ContactsStddevOrderBy>;
  stddev_pop?: InputMaybe<ContactsStddevPopOrderBy>;
  stddev_samp?: InputMaybe<ContactsStddevSampOrderBy>;
  sum?: InputMaybe<ContactsSumOrderBy>;
  var_pop?: InputMaybe<ContactsVarPopOrderBy>;
  var_samp?: InputMaybe<ContactsVarSampOrderBy>;
  variance?: InputMaybe<ContactsVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "contacts" */
export type ContactsArrRelInsertInput = {
  data: Array<ContactsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<ContactsOnConflict>;
};

/** aggregate avg on columns */
export type ContactsAvgFields = {
  __typename?: "contacts_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "contacts" */
export type ContactsAvgOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "contacts". All fields are combined with a logical 'AND'. */
export type ContactsBoolExp = {
  _and?: InputMaybe<Array<ContactsBoolExp>>;
  _not?: InputMaybe<ContactsBoolExp>;
  _or?: InputMaybe<Array<ContactsBoolExp>>;
  company?: InputMaybe<CompaniesBoolExp>;
  company_contacts?: InputMaybe<CompanyContactsBoolExp>;
  company_contacts_aggregate?: InputMaybe<CompanyContactsAggregateBoolExp>;
  company_id?: InputMaybe<UuidComparisonExp>;
  contact_type?: InputMaybe<ContactTypeComparisonExp>;
  created_at?: InputMaybe<TimestampComparisonExp>;
  email?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  is_primary?: InputMaybe<BooleanComparisonExp>;
  phone?: InputMaybe<StringComparisonExp>;
  privacy_level?: InputMaybe<PrivacyLevelComparisonExp>;
  title?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestampComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
  user_profile?: InputMaybe<UserProfilesBoolExp>;
};

/** unique or primary key constraints on table "contacts" */
export enum ContactsConstraint {
  /** unique or primary key constraint on columns "id" */
  CONTACTS_PKEY = "contacts_pkey",
}

/** input type for incrementing numeric columns in table "contacts" */
export type ContactsIncInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "contacts" */
export type ContactsInsertInput = {
  company?: InputMaybe<CompaniesObjRelInsertInput>;
  company_contacts?: InputMaybe<CompanyContactsArrRelInsertInput>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  contact_type?: InputMaybe<Scalars["contact_type"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  email?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
  phone?: InputMaybe<Scalars["String"]["input"]>;
  privacy_level?: InputMaybe<Scalars["privacy_level"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
};

/** aggregate max on columns */
export type ContactsMaxFields = {
  __typename?: "contacts_max_fields";
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  contact_type?: Maybe<Scalars["contact_type"]["output"]>;
  created_at?: Maybe<Scalars["timestamp"]["output"]>;
  email?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  phone?: Maybe<Scalars["String"]["output"]>;
  privacy_level?: Maybe<Scalars["privacy_level"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamp"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by max() on columns of table "contacts" */
export type ContactsMaxOrderBy = {
  company_id?: InputMaybe<OrderBy>;
  contact_type?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  email?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  phone?: InputMaybe<OrderBy>;
  privacy_level?: InputMaybe<OrderBy>;
  title?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type ContactsMinFields = {
  __typename?: "contacts_min_fields";
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  contact_type?: Maybe<Scalars["contact_type"]["output"]>;
  created_at?: Maybe<Scalars["timestamp"]["output"]>;
  email?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  phone?: Maybe<Scalars["String"]["output"]>;
  privacy_level?: Maybe<Scalars["privacy_level"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamp"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by min() on columns of table "contacts" */
export type ContactsMinOrderBy = {
  company_id?: InputMaybe<OrderBy>;
  contact_type?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  email?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  phone?: InputMaybe<OrderBy>;
  privacy_level?: InputMaybe<OrderBy>;
  title?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "contacts" */
export type ContactsMutationResponse = {
  __typename?: "contacts_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Contacts>;
};

/** input type for inserting object relation for remote table "contacts" */
export type ContactsObjRelInsertInput = {
  data: ContactsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<ContactsOnConflict>;
};

/** on_conflict condition type for table "contacts" */
export type ContactsOnConflict = {
  constraint: ContactsConstraint;
  update_columns?: Array<ContactsUpdateColumn>;
  where?: InputMaybe<ContactsBoolExp>;
};

/** Ordering options when selecting data from "contacts". */
export type ContactsOrderBy = {
  company?: InputMaybe<CompaniesOrderBy>;
  company_contacts_aggregate?: InputMaybe<CompanyContactsAggregateOrderBy>;
  company_id?: InputMaybe<OrderBy>;
  contact_type?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  email?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  is_primary?: InputMaybe<OrderBy>;
  phone?: InputMaybe<OrderBy>;
  privacy_level?: InputMaybe<OrderBy>;
  title?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  user_profile?: InputMaybe<UserProfilesOrderBy>;
};

/** primary key columns input for table: contacts */
export type ContactsPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "contacts" */
export enum ContactsSelectColumn {
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CONTACT_TYPE = "contact_type",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  EMAIL = "email",
  /** column name */
  ID = "id",
  /** column name */
  IS_PRIMARY = "is_primary",
  /** column name */
  PHONE = "phone",
  /** column name */
  PRIVACY_LEVEL = "privacy_level",
  /** column name */
  TITLE = "title",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

/** select "contacts_aggregate_bool_exp_bool_and_arguments_columns" columns of table "contacts" */
export enum ContactsSelectColumnContactsAggregateBoolExpBoolAndArgumentsColumns {
  /** column name */
  IS_PRIMARY = "is_primary",
}

/** select "contacts_aggregate_bool_exp_bool_or_arguments_columns" columns of table "contacts" */
export enum ContactsSelectColumnContactsAggregateBoolExpBoolOrArgumentsColumns {
  /** column name */
  IS_PRIMARY = "is_primary",
}

/** input type for updating data in table "contacts" */
export type ContactsSetInput = {
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  contact_type?: InputMaybe<Scalars["contact_type"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  email?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
  phone?: InputMaybe<Scalars["String"]["input"]>;
  privacy_level?: InputMaybe<Scalars["privacy_level"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate stddev on columns */
export type ContactsStddevFields = {
  __typename?: "contacts_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "contacts" */
export type ContactsStddevOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type ContactsStddevPopFields = {
  __typename?: "contacts_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "contacts" */
export type ContactsStddevPopOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type ContactsStddevSampFields = {
  __typename?: "contacts_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "contacts" */
export type ContactsStddevSampOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "contacts" */
export type ContactsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ContactsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ContactsStreamCursorValueInput = {
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  contact_type?: InputMaybe<Scalars["contact_type"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  email?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
  phone?: InputMaybe<Scalars["String"]["input"]>;
  privacy_level?: InputMaybe<Scalars["privacy_level"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate sum on columns */
export type ContactsSumFields = {
  __typename?: "contacts_sum_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "contacts" */
export type ContactsSumOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** update columns of table "contacts" */
export enum ContactsUpdateColumn {
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CONTACT_TYPE = "contact_type",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  EMAIL = "email",
  /** column name */
  ID = "id",
  /** column name */
  IS_PRIMARY = "is_primary",
  /** column name */
  PHONE = "phone",
  /** column name */
  PRIVACY_LEVEL = "privacy_level",
  /** column name */
  TITLE = "title",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

export type ContactsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<ContactsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<ContactsSetInput>;
  /** filter the rows which have to be updated */
  where: ContactsBoolExp;
};

/** aggregate var_pop on columns */
export type ContactsVarPopFields = {
  __typename?: "contacts_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "contacts" */
export type ContactsVarPopOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type ContactsVarSampFields = {
  __typename?: "contacts_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "contacts" */
export type ContactsVarSampOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type ContactsVarianceFields = {
  __typename?: "contacts_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "contacts" */
export type ContactsVarianceOrderBy = {
  id?: InputMaybe<OrderBy>;
};

/** columns and relationships of "content_categories" */
export type ContentCategories = {
  __typename?: "content_categories";
  /** An object relationship */
  category: Categories;
  category_id: Scalars["bigint"]["output"];
  /** An object relationship */
  content: Contents;
  content_id: Scalars["uuid"]["output"];
  is_primary: Scalars["Boolean"]["output"];
};

/** aggregated selection of "content_categories" */
export type ContentCategoriesAggregate = {
  __typename?: "content_categories_aggregate";
  aggregate?: Maybe<ContentCategoriesAggregateFields>;
  nodes: Array<ContentCategories>;
};

export type ContentCategoriesAggregateBoolExp = {
  bool_and?: InputMaybe<ContentCategoriesAggregateBoolExpBoolAnd>;
  bool_or?: InputMaybe<ContentCategoriesAggregateBoolExpBoolOr>;
  count?: InputMaybe<ContentCategoriesAggregateBoolExpCount>;
};

export type ContentCategoriesAggregateBoolExpBoolAnd = {
  arguments: ContentCategoriesSelectColumnContentCategoriesAggregateBoolExpBoolAndArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ContentCategoriesBoolExp>;
  predicate: BooleanComparisonExp;
};

export type ContentCategoriesAggregateBoolExpBoolOr = {
  arguments: ContentCategoriesSelectColumnContentCategoriesAggregateBoolExpBoolOrArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ContentCategoriesBoolExp>;
  predicate: BooleanComparisonExp;
};

export type ContentCategoriesAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<ContentCategoriesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ContentCategoriesBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "content_categories" */
export type ContentCategoriesAggregateFields = {
  __typename?: "content_categories_aggregate_fields";
  avg?: Maybe<ContentCategoriesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ContentCategoriesMaxFields>;
  min?: Maybe<ContentCategoriesMinFields>;
  stddev?: Maybe<ContentCategoriesStddevFields>;
  stddev_pop?: Maybe<ContentCategoriesStddevPopFields>;
  stddev_samp?: Maybe<ContentCategoriesStddevSampFields>;
  sum?: Maybe<ContentCategoriesSumFields>;
  var_pop?: Maybe<ContentCategoriesVarPopFields>;
  var_samp?: Maybe<ContentCategoriesVarSampFields>;
  variance?: Maybe<ContentCategoriesVarianceFields>;
};

/** aggregate fields of "content_categories" */
export type ContentCategoriesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ContentCategoriesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "content_categories" */
export type ContentCategoriesAggregateOrderBy = {
  avg?: InputMaybe<ContentCategoriesAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<ContentCategoriesMaxOrderBy>;
  min?: InputMaybe<ContentCategoriesMinOrderBy>;
  stddev?: InputMaybe<ContentCategoriesStddevOrderBy>;
  stddev_pop?: InputMaybe<ContentCategoriesStddevPopOrderBy>;
  stddev_samp?: InputMaybe<ContentCategoriesStddevSampOrderBy>;
  sum?: InputMaybe<ContentCategoriesSumOrderBy>;
  var_pop?: InputMaybe<ContentCategoriesVarPopOrderBy>;
  var_samp?: InputMaybe<ContentCategoriesVarSampOrderBy>;
  variance?: InputMaybe<ContentCategoriesVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "content_categories" */
export type ContentCategoriesArrRelInsertInput = {
  data: Array<ContentCategoriesInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<ContentCategoriesOnConflict>;
};

/** aggregate avg on columns */
export type ContentCategoriesAvgFields = {
  __typename?: "content_categories_avg_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "content_categories" */
export type ContentCategoriesAvgOrderBy = {
  category_id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "content_categories". All fields are combined with a logical 'AND'. */
export type ContentCategoriesBoolExp = {
  _and?: InputMaybe<Array<ContentCategoriesBoolExp>>;
  _not?: InputMaybe<ContentCategoriesBoolExp>;
  _or?: InputMaybe<Array<ContentCategoriesBoolExp>>;
  category?: InputMaybe<CategoriesBoolExp>;
  category_id?: InputMaybe<BigintComparisonExp>;
  content?: InputMaybe<ContentsBoolExp>;
  content_id?: InputMaybe<UuidComparisonExp>;
  is_primary?: InputMaybe<BooleanComparisonExp>;
};

/** unique or primary key constraints on table "content_categories" */
export enum ContentCategoriesConstraint {
  /** unique or primary key constraint on columns "content_id", "category_id" */
  CONTENT_CATEGORIES_PKEY = "content_categories_pkey",
}

/** input type for incrementing numeric columns in table "content_categories" */
export type ContentCategoriesIncInput = {
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** input type for inserting data into table "content_categories" */
export type ContentCategoriesInsertInput = {
  category?: InputMaybe<CategoriesObjRelInsertInput>;
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  content?: InputMaybe<ContentsObjRelInsertInput>;
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate max on columns */
export type ContentCategoriesMaxFields = {
  __typename?: "content_categories_max_fields";
  category_id?: Maybe<Scalars["bigint"]["output"]>;
  content_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by max() on columns of table "content_categories" */
export type ContentCategoriesMaxOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  content_id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type ContentCategoriesMinFields = {
  __typename?: "content_categories_min_fields";
  category_id?: Maybe<Scalars["bigint"]["output"]>;
  content_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by min() on columns of table "content_categories" */
export type ContentCategoriesMinOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  content_id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "content_categories" */
export type ContentCategoriesMutationResponse = {
  __typename?: "content_categories_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<ContentCategories>;
};

/** on_conflict condition type for table "content_categories" */
export type ContentCategoriesOnConflict = {
  constraint: ContentCategoriesConstraint;
  update_columns?: Array<ContentCategoriesUpdateColumn>;
  where?: InputMaybe<ContentCategoriesBoolExp>;
};

/** Ordering options when selecting data from "content_categories". */
export type ContentCategoriesOrderBy = {
  category?: InputMaybe<CategoriesOrderBy>;
  category_id?: InputMaybe<OrderBy>;
  content?: InputMaybe<ContentsOrderBy>;
  content_id?: InputMaybe<OrderBy>;
  is_primary?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: content_categories */
export type ContentCategoriesPkColumnsInput = {
  category_id: Scalars["bigint"]["input"];
  content_id: Scalars["uuid"]["input"];
};

/** select columns of table "content_categories" */
export enum ContentCategoriesSelectColumn {
  /** column name */
  CATEGORY_ID = "category_id",
  /** column name */
  CONTENT_ID = "content_id",
  /** column name */
  IS_PRIMARY = "is_primary",
}

/** select "content_categories_aggregate_bool_exp_bool_and_arguments_columns" columns of table "content_categories" */
export enum ContentCategoriesSelectColumnContentCategoriesAggregateBoolExpBoolAndArgumentsColumns {
  /** column name */
  IS_PRIMARY = "is_primary",
}

/** select "content_categories_aggregate_bool_exp_bool_or_arguments_columns" columns of table "content_categories" */
export enum ContentCategoriesSelectColumnContentCategoriesAggregateBoolExpBoolOrArgumentsColumns {
  /** column name */
  IS_PRIMARY = "is_primary",
}

/** input type for updating data in table "content_categories" */
export type ContentCategoriesSetInput = {
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate stddev on columns */
export type ContentCategoriesStddevFields = {
  __typename?: "content_categories_stddev_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "content_categories" */
export type ContentCategoriesStddevOrderBy = {
  category_id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type ContentCategoriesStddevPopFields = {
  __typename?: "content_categories_stddev_pop_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "content_categories" */
export type ContentCategoriesStddevPopOrderBy = {
  category_id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type ContentCategoriesStddevSampFields = {
  __typename?: "content_categories_stddev_samp_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "content_categories" */
export type ContentCategoriesStddevSampOrderBy = {
  category_id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "content_categories" */
export type ContentCategoriesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ContentCategoriesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ContentCategoriesStreamCursorValueInput = {
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate sum on columns */
export type ContentCategoriesSumFields = {
  __typename?: "content_categories_sum_fields";
  category_id?: Maybe<Scalars["bigint"]["output"]>;
};

/** order by sum() on columns of table "content_categories" */
export type ContentCategoriesSumOrderBy = {
  category_id?: InputMaybe<OrderBy>;
};

/** update columns of table "content_categories" */
export enum ContentCategoriesUpdateColumn {
  /** column name */
  CATEGORY_ID = "category_id",
  /** column name */
  CONTENT_ID = "content_id",
  /** column name */
  IS_PRIMARY = "is_primary",
}

export type ContentCategoriesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<ContentCategoriesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<ContentCategoriesSetInput>;
  /** filter the rows which have to be updated */
  where: ContentCategoriesBoolExp;
};

/** aggregate var_pop on columns */
export type ContentCategoriesVarPopFields = {
  __typename?: "content_categories_var_pop_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "content_categories" */
export type ContentCategoriesVarPopOrderBy = {
  category_id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type ContentCategoriesVarSampFields = {
  __typename?: "content_categories_var_samp_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "content_categories" */
export type ContentCategoriesVarSampOrderBy = {
  category_id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type ContentCategoriesVarianceFields = {
  __typename?: "content_categories_variance_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "content_categories" */
export type ContentCategoriesVarianceOrderBy = {
  category_id?: InputMaybe<OrderBy>;
};

/** columns and relationships of "content_scores" */
export type ContentScores = {
  __typename?: "content_scores";
  categories?: Maybe<Scalars["jsonb"]["output"]>;
  content_type?: Maybe<Scalars["content_type"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  hot_score?: Maybe<Scalars["float8"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  status?: Maybe<Scalars["content_status"]["output"]>;
  tags?: Maybe<Scalars["jsonb"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** columns and relationships of "content_scores" */
export type ContentScoresCategoriesArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "content_scores" */
export type ContentScoresTagsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "content_scores" */
export type ContentScoresAggregate = {
  __typename?: "content_scores_aggregate";
  aggregate?: Maybe<ContentScoresAggregateFields>;
  nodes: Array<ContentScores>;
};

/** aggregate fields of "content_scores" */
export type ContentScoresAggregateFields = {
  __typename?: "content_scores_aggregate_fields";
  avg?: Maybe<ContentScoresAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ContentScoresMaxFields>;
  min?: Maybe<ContentScoresMinFields>;
  stddev?: Maybe<ContentScoresStddevFields>;
  stddev_pop?: Maybe<ContentScoresStddevPopFields>;
  stddev_samp?: Maybe<ContentScoresStddevSampFields>;
  sum?: Maybe<ContentScoresSumFields>;
  var_pop?: Maybe<ContentScoresVarPopFields>;
  var_samp?: Maybe<ContentScoresVarSampFields>;
  variance?: Maybe<ContentScoresVarianceFields>;
};

/** aggregate fields of "content_scores" */
export type ContentScoresAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ContentScoresSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type ContentScoresAvgFields = {
  __typename?: "content_scores_avg_fields";
  hot_score?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "content_scores". All fields are combined with a logical 'AND'. */
export type ContentScoresBoolExp = {
  _and?: InputMaybe<Array<ContentScoresBoolExp>>;
  _not?: InputMaybe<ContentScoresBoolExp>;
  _or?: InputMaybe<Array<ContentScoresBoolExp>>;
  categories?: InputMaybe<JsonbComparisonExp>;
  content_type?: InputMaybe<ContentTypeComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  hot_score?: InputMaybe<Float8ComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  status?: InputMaybe<ContentStatusComparisonExp>;
  tags?: InputMaybe<JsonbComparisonExp>;
  title?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  url?: InputMaybe<StringComparisonExp>;
};

/** aggregate max on columns */
export type ContentScoresMaxFields = {
  __typename?: "content_scores_max_fields";
  content_type?: Maybe<Scalars["content_type"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  hot_score?: Maybe<Scalars["float8"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  status?: Maybe<Scalars["content_status"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** aggregate min on columns */
export type ContentScoresMinFields = {
  __typename?: "content_scores_min_fields";
  content_type?: Maybe<Scalars["content_type"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  hot_score?: Maybe<Scalars["float8"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  status?: Maybe<Scalars["content_status"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** Ordering options when selecting data from "content_scores". */
export type ContentScoresOrderBy = {
  categories?: InputMaybe<OrderBy>;
  content_type?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  hot_score?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  status?: InputMaybe<OrderBy>;
  tags?: InputMaybe<OrderBy>;
  title?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** select columns of table "content_scores" */
export enum ContentScoresSelectColumn {
  /** column name */
  CATEGORIES = "categories",
  /** column name */
  CONTENT_TYPE = "content_type",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  HOT_SCORE = "hot_score",
  /** column name */
  ID = "id",
  /** column name */
  STATUS = "status",
  /** column name */
  TAGS = "tags",
  /** column name */
  TITLE = "title",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
}

/** aggregate stddev on columns */
export type ContentScoresStddevFields = {
  __typename?: "content_scores_stddev_fields";
  hot_score?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type ContentScoresStddevPopFields = {
  __typename?: "content_scores_stddev_pop_fields";
  hot_score?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type ContentScoresStddevSampFields = {
  __typename?: "content_scores_stddev_samp_fields";
  hot_score?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "content_scores" */
export type ContentScoresStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ContentScoresStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ContentScoresStreamCursorValueInput = {
  categories?: InputMaybe<Scalars["jsonb"]["input"]>;
  content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  hot_score?: InputMaybe<Scalars["float8"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  status?: InputMaybe<Scalars["content_status"]["input"]>;
  tags?: InputMaybe<Scalars["jsonb"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type ContentScoresSumFields = {
  __typename?: "content_scores_sum_fields";
  hot_score?: Maybe<Scalars["float8"]["output"]>;
};

/** aggregate var_pop on columns */
export type ContentScoresVarPopFields = {
  __typename?: "content_scores_var_pop_fields";
  hot_score?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type ContentScoresVarSampFields = {
  __typename?: "content_scores_var_samp_fields";
  hot_score?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type ContentScoresVarianceFields = {
  __typename?: "content_scores_variance_fields";
  hot_score?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "content_source_visits" */
export type ContentSourceVisits = {
  __typename?: "content_source_visits";
  /** An object relationship */
  content: Contents;
  content_id: Scalars["uuid"]["output"];
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id: Scalars["uuid"]["output"];
  user_id?: Maybe<Scalars["uuid"]["output"]>;
  /** An object relationship */
  user_profile?: Maybe<UserProfiles>;
};

/** aggregated selection of "content_source_visits" */
export type ContentSourceVisitsAggregate = {
  __typename?: "content_source_visits_aggregate";
  aggregate?: Maybe<ContentSourceVisitsAggregateFields>;
  nodes: Array<ContentSourceVisits>;
};

export type ContentSourceVisitsAggregateBoolExp = {
  count?: InputMaybe<ContentSourceVisitsAggregateBoolExpCount>;
};

export type ContentSourceVisitsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<ContentSourceVisitsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ContentSourceVisitsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "content_source_visits" */
export type ContentSourceVisitsAggregateFields = {
  __typename?: "content_source_visits_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<ContentSourceVisitsMaxFields>;
  min?: Maybe<ContentSourceVisitsMinFields>;
};

/** aggregate fields of "content_source_visits" */
export type ContentSourceVisitsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ContentSourceVisitsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "content_source_visits" */
export type ContentSourceVisitsAggregateOrderBy = {
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<ContentSourceVisitsMaxOrderBy>;
  min?: InputMaybe<ContentSourceVisitsMinOrderBy>;
};

/** input type for inserting array relation for remote table "content_source_visits" */
export type ContentSourceVisitsArrRelInsertInput = {
  data: Array<ContentSourceVisitsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<ContentSourceVisitsOnConflict>;
};

/** Boolean expression to filter rows from the table "content_source_visits". All fields are combined with a logical 'AND'. */
export type ContentSourceVisitsBoolExp = {
  _and?: InputMaybe<Array<ContentSourceVisitsBoolExp>>;
  _not?: InputMaybe<ContentSourceVisitsBoolExp>;
  _or?: InputMaybe<Array<ContentSourceVisitsBoolExp>>;
  content?: InputMaybe<ContentsBoolExp>;
  content_id?: InputMaybe<UuidComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
  user_profile?: InputMaybe<UserProfilesBoolExp>;
};

/** unique or primary key constraints on table "content_source_visits" */
export enum ContentSourceVisitsConstraint {
  /** unique or primary key constraint on columns "id" */
  CONTENT_SOURCE_VISITS_PKEY = "content_source_visits_pkey",
}

/** input type for inserting data into table "content_source_visits" */
export type ContentSourceVisitsInsertInput = {
  content?: InputMaybe<ContentsObjRelInsertInput>;
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
};

/** aggregate max on columns */
export type ContentSourceVisitsMaxFields = {
  __typename?: "content_source_visits_max_fields";
  content_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by max() on columns of table "content_source_visits" */
export type ContentSourceVisitsMaxOrderBy = {
  content_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type ContentSourceVisitsMinFields = {
  __typename?: "content_source_visits_min_fields";
  content_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by min() on columns of table "content_source_visits" */
export type ContentSourceVisitsMinOrderBy = {
  content_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "content_source_visits" */
export type ContentSourceVisitsMutationResponse = {
  __typename?: "content_source_visits_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<ContentSourceVisits>;
};

/** on_conflict condition type for table "content_source_visits" */
export type ContentSourceVisitsOnConflict = {
  constraint: ContentSourceVisitsConstraint;
  update_columns?: Array<ContentSourceVisitsUpdateColumn>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

/** Ordering options when selecting data from "content_source_visits". */
export type ContentSourceVisitsOrderBy = {
  content?: InputMaybe<ContentsOrderBy>;
  content_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  user_profile?: InputMaybe<UserProfilesOrderBy>;
};

/** primary key columns input for table: content_source_visits */
export type ContentSourceVisitsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "content_source_visits" */
export enum ContentSourceVisitsSelectColumn {
  /** column name */
  CONTENT_ID = "content_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  USER_ID = "user_id",
}

/** input type for updating data in table "content_source_visits" */
export type ContentSourceVisitsSetInput = {
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** Streaming cursor of the table "content_source_visits" */
export type ContentSourceVisitsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ContentSourceVisitsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ContentSourceVisitsStreamCursorValueInput = {
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** update columns of table "content_source_visits" */
export enum ContentSourceVisitsUpdateColumn {
  /** column name */
  CONTENT_ID = "content_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  USER_ID = "user_id",
}

export type ContentSourceVisitsUpdates = {
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<ContentSourceVisitsSetInput>;
  /** filter the rows which have to be updated */
  where: ContentSourceVisitsBoolExp;
};

/** columns and relationships of "content_sources" */
export type ContentSources = {
  __typename?: "content_sources";
  /** An object relationship */
  company?: Maybe<Companies>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  content_type: Scalars["content_type"]["output"];
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  expected_count?: Maybe<Scalars["smallint"]["output"]>;
  failed_count?: Maybe<Scalars["smallint"]["output"]>;
  /** An array relationship */
  feed_sources: Array<FeedSources>;
  /** An aggregate relationship */
  feed_sources_aggregate: FeedSourcesAggregate;
  has_failed?: Maybe<Scalars["Boolean"]["output"]>;
  hash?: Maybe<Scalars["bigint"]["output"]>;
  id: Scalars["bigint"]["output"];
  /** An array relationship */
  news: Array<News>;
  /** An aggregate relationship */
  news_aggregate: NewsAggregate;
  priority: Scalars["priority"]["output"];
  refreshed_at?: Maybe<Scalars["timestamptz"]["output"]>;
  rss_urls?: Maybe<Array<Scalars["String"]["output"]>>;
  scrape_frequency: Scalars["scrape_frequency"]["output"];
  scraped_at?: Maybe<Scalars["timestamptz"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url: Scalars["String"]["output"];
};

/** columns and relationships of "content_sources" */
export type ContentSourcesFeedSourcesArgs = {
  distinct_on?: InputMaybe<Array<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

/** columns and relationships of "content_sources" */
export type ContentSourcesFeedSourcesAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

/** columns and relationships of "content_sources" */
export type ContentSourcesNewsArgs = {
  distinct_on?: InputMaybe<Array<NewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsOrderBy>>;
  where?: InputMaybe<NewsBoolExp>;
};

/** columns and relationships of "content_sources" */
export type ContentSourcesNewsAggregateArgs = {
  distinct_on?: InputMaybe<Array<NewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsOrderBy>>;
  where?: InputMaybe<NewsBoolExp>;
};

/** aggregated selection of "content_sources" */
export type ContentSourcesAggregate = {
  __typename?: "content_sources_aggregate";
  aggregate?: Maybe<ContentSourcesAggregateFields>;
  nodes: Array<ContentSources>;
};

export type ContentSourcesAggregateBoolExp = {
  bool_and?: InputMaybe<ContentSourcesAggregateBoolExpBoolAnd>;
  bool_or?: InputMaybe<ContentSourcesAggregateBoolExpBoolOr>;
  count?: InputMaybe<ContentSourcesAggregateBoolExpCount>;
};

export type ContentSourcesAggregateBoolExpBoolAnd = {
  arguments: ContentSourcesSelectColumnContentSourcesAggregateBoolExpBoolAndArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ContentSourcesBoolExp>;
  predicate: BooleanComparisonExp;
};

export type ContentSourcesAggregateBoolExpBoolOr = {
  arguments: ContentSourcesSelectColumnContentSourcesAggregateBoolExpBoolOrArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ContentSourcesBoolExp>;
  predicate: BooleanComparisonExp;
};

export type ContentSourcesAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<ContentSourcesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ContentSourcesBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "content_sources" */
export type ContentSourcesAggregateFields = {
  __typename?: "content_sources_aggregate_fields";
  avg?: Maybe<ContentSourcesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ContentSourcesMaxFields>;
  min?: Maybe<ContentSourcesMinFields>;
  stddev?: Maybe<ContentSourcesStddevFields>;
  stddev_pop?: Maybe<ContentSourcesStddevPopFields>;
  stddev_samp?: Maybe<ContentSourcesStddevSampFields>;
  sum?: Maybe<ContentSourcesSumFields>;
  var_pop?: Maybe<ContentSourcesVarPopFields>;
  var_samp?: Maybe<ContentSourcesVarSampFields>;
  variance?: Maybe<ContentSourcesVarianceFields>;
};

/** aggregate fields of "content_sources" */
export type ContentSourcesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ContentSourcesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "content_sources" */
export type ContentSourcesAggregateOrderBy = {
  avg?: InputMaybe<ContentSourcesAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<ContentSourcesMaxOrderBy>;
  min?: InputMaybe<ContentSourcesMinOrderBy>;
  stddev?: InputMaybe<ContentSourcesStddevOrderBy>;
  stddev_pop?: InputMaybe<ContentSourcesStddevPopOrderBy>;
  stddev_samp?: InputMaybe<ContentSourcesStddevSampOrderBy>;
  sum?: InputMaybe<ContentSourcesSumOrderBy>;
  var_pop?: InputMaybe<ContentSourcesVarPopOrderBy>;
  var_samp?: InputMaybe<ContentSourcesVarSampOrderBy>;
  variance?: InputMaybe<ContentSourcesVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "content_sources" */
export type ContentSourcesArrRelInsertInput = {
  data: Array<ContentSourcesInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<ContentSourcesOnConflict>;
};

/** aggregate avg on columns */
export type ContentSourcesAvgFields = {
  __typename?: "content_sources_avg_fields";
  expected_count?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  hash?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "content_sources" */
export type ContentSourcesAvgOrderBy = {
  expected_count?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "content_sources". All fields are combined with a logical 'AND'. */
export type ContentSourcesBoolExp = {
  _and?: InputMaybe<Array<ContentSourcesBoolExp>>;
  _not?: InputMaybe<ContentSourcesBoolExp>;
  _or?: InputMaybe<Array<ContentSourcesBoolExp>>;
  company?: InputMaybe<CompaniesBoolExp>;
  company_id?: InputMaybe<UuidComparisonExp>;
  content_type?: InputMaybe<ContentTypeComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  expected_count?: InputMaybe<SmallintComparisonExp>;
  failed_count?: InputMaybe<SmallintComparisonExp>;
  feed_sources?: InputMaybe<FeedSourcesBoolExp>;
  feed_sources_aggregate?: InputMaybe<FeedSourcesAggregateBoolExp>;
  has_failed?: InputMaybe<BooleanComparisonExp>;
  hash?: InputMaybe<BigintComparisonExp>;
  id?: InputMaybe<BigintComparisonExp>;
  news?: InputMaybe<NewsBoolExp>;
  news_aggregate?: InputMaybe<NewsAggregateBoolExp>;
  priority?: InputMaybe<PriorityComparisonExp>;
  refreshed_at?: InputMaybe<TimestamptzComparisonExp>;
  rss_urls?: InputMaybe<StringArrayComparisonExp>;
  scrape_frequency?: InputMaybe<ScrapeFrequencyComparisonExp>;
  scraped_at?: InputMaybe<TimestamptzComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  url?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "content_sources" */
export enum ContentSourcesConstraint {
  /** unique or primary key constraint on columns "id" */
  CONTENT_SOURCES_PKEY1 = "content_sources_pkey1",
  /** unique or primary key constraint on columns "url" */
  CONTENT_SOURCES_URL_KEY1 = "content_sources_url_key1",
}

/** input type for incrementing numeric columns in table "content_sources" */
export type ContentSourcesIncInput = {
  expected_count?: InputMaybe<Scalars["smallint"]["input"]>;
  failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  hash?: InputMaybe<Scalars["bigint"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** input type for inserting data into table "content_sources" */
export type ContentSourcesInsertInput = {
  company?: InputMaybe<CompaniesObjRelInsertInput>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  expected_count?: InputMaybe<Scalars["smallint"]["input"]>;
  failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  feed_sources?: InputMaybe<FeedSourcesArrRelInsertInput>;
  has_failed?: InputMaybe<Scalars["Boolean"]["input"]>;
  hash?: InputMaybe<Scalars["bigint"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  news?: InputMaybe<NewsArrRelInsertInput>;
  priority?: InputMaybe<Scalars["priority"]["input"]>;
  refreshed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  rss_urls?: InputMaybe<Array<Scalars["String"]["input"]>>;
  scrape_frequency?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  scraped_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type ContentSourcesMaxFields = {
  __typename?: "content_sources_max_fields";
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  content_type?: Maybe<Scalars["content_type"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  expected_count?: Maybe<Scalars["smallint"]["output"]>;
  failed_count?: Maybe<Scalars["smallint"]["output"]>;
  hash?: Maybe<Scalars["bigint"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  priority?: Maybe<Scalars["priority"]["output"]>;
  refreshed_at?: Maybe<Scalars["timestamptz"]["output"]>;
  rss_urls?: Maybe<Array<Scalars["String"]["output"]>>;
  scrape_frequency?: Maybe<Scalars["scrape_frequency"]["output"]>;
  scraped_at?: Maybe<Scalars["timestamptz"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** order by max() on columns of table "content_sources" */
export type ContentSourcesMaxOrderBy = {
  company_id?: InputMaybe<OrderBy>;
  content_type?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  expected_count?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  priority?: InputMaybe<OrderBy>;
  refreshed_at?: InputMaybe<OrderBy>;
  rss_urls?: InputMaybe<OrderBy>;
  scrape_frequency?: InputMaybe<OrderBy>;
  scraped_at?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type ContentSourcesMinFields = {
  __typename?: "content_sources_min_fields";
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  content_type?: Maybe<Scalars["content_type"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  expected_count?: Maybe<Scalars["smallint"]["output"]>;
  failed_count?: Maybe<Scalars["smallint"]["output"]>;
  hash?: Maybe<Scalars["bigint"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  priority?: Maybe<Scalars["priority"]["output"]>;
  refreshed_at?: Maybe<Scalars["timestamptz"]["output"]>;
  rss_urls?: Maybe<Array<Scalars["String"]["output"]>>;
  scrape_frequency?: Maybe<Scalars["scrape_frequency"]["output"]>;
  scraped_at?: Maybe<Scalars["timestamptz"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** order by min() on columns of table "content_sources" */
export type ContentSourcesMinOrderBy = {
  company_id?: InputMaybe<OrderBy>;
  content_type?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  expected_count?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  priority?: InputMaybe<OrderBy>;
  refreshed_at?: InputMaybe<OrderBy>;
  rss_urls?: InputMaybe<OrderBy>;
  scrape_frequency?: InputMaybe<OrderBy>;
  scraped_at?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "content_sources" */
export type ContentSourcesMutationResponse = {
  __typename?: "content_sources_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<ContentSources>;
};

/** input type for inserting object relation for remote table "content_sources" */
export type ContentSourcesObjRelInsertInput = {
  data: ContentSourcesInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<ContentSourcesOnConflict>;
};

/** on_conflict condition type for table "content_sources" */
export type ContentSourcesOnConflict = {
  constraint: ContentSourcesConstraint;
  update_columns?: Array<ContentSourcesUpdateColumn>;
  where?: InputMaybe<ContentSourcesBoolExp>;
};

/** Ordering options when selecting data from "content_sources". */
export type ContentSourcesOrderBy = {
  company?: InputMaybe<CompaniesOrderBy>;
  company_id?: InputMaybe<OrderBy>;
  content_type?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  expected_count?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  feed_sources_aggregate?: InputMaybe<FeedSourcesAggregateOrderBy>;
  has_failed?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  news_aggregate?: InputMaybe<NewsAggregateOrderBy>;
  priority?: InputMaybe<OrderBy>;
  refreshed_at?: InputMaybe<OrderBy>;
  rss_urls?: InputMaybe<OrderBy>;
  scrape_frequency?: InputMaybe<OrderBy>;
  scraped_at?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: content_sources */
export type ContentSourcesPkColumnsInput = {
  id: Scalars["bigint"]["input"];
};

/** select columns of table "content_sources" */
export enum ContentSourcesSelectColumn {
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CONTENT_TYPE = "content_type",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  EXPECTED_COUNT = "expected_count",
  /** column name */
  FAILED_COUNT = "failed_count",
  /** column name */
  HAS_FAILED = "has_failed",
  /** column name */
  HASH = "hash",
  /** column name */
  ID = "id",
  /** column name */
  PRIORITY = "priority",
  /** column name */
  REFRESHED_AT = "refreshed_at",
  /** column name */
  RSS_URLS = "rss_urls",
  /** column name */
  SCRAPE_FREQUENCY = "scrape_frequency",
  /** column name */
  SCRAPED_AT = "scraped_at",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
}

/** select "content_sources_aggregate_bool_exp_bool_and_arguments_columns" columns of table "content_sources" */
export enum ContentSourcesSelectColumnContentSourcesAggregateBoolExpBoolAndArgumentsColumns {
  /** column name */
  HAS_FAILED = "has_failed",
}

/** select "content_sources_aggregate_bool_exp_bool_or_arguments_columns" columns of table "content_sources" */
export enum ContentSourcesSelectColumnContentSourcesAggregateBoolExpBoolOrArgumentsColumns {
  /** column name */
  HAS_FAILED = "has_failed",
}

/** input type for updating data in table "content_sources" */
export type ContentSourcesSetInput = {
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  expected_count?: InputMaybe<Scalars["smallint"]["input"]>;
  failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  has_failed?: InputMaybe<Scalars["Boolean"]["input"]>;
  hash?: InputMaybe<Scalars["bigint"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  priority?: InputMaybe<Scalars["priority"]["input"]>;
  refreshed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  rss_urls?: InputMaybe<Array<Scalars["String"]["input"]>>;
  scrape_frequency?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  scraped_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type ContentSourcesStddevFields = {
  __typename?: "content_sources_stddev_fields";
  expected_count?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  hash?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "content_sources" */
export type ContentSourcesStddevOrderBy = {
  expected_count?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type ContentSourcesStddevPopFields = {
  __typename?: "content_sources_stddev_pop_fields";
  expected_count?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  hash?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "content_sources" */
export type ContentSourcesStddevPopOrderBy = {
  expected_count?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type ContentSourcesStddevSampFields = {
  __typename?: "content_sources_stddev_samp_fields";
  expected_count?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  hash?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "content_sources" */
export type ContentSourcesStddevSampOrderBy = {
  expected_count?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "content_sources" */
export type ContentSourcesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ContentSourcesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ContentSourcesStreamCursorValueInput = {
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  expected_count?: InputMaybe<Scalars["smallint"]["input"]>;
  failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  has_failed?: InputMaybe<Scalars["Boolean"]["input"]>;
  hash?: InputMaybe<Scalars["bigint"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  priority?: InputMaybe<Scalars["priority"]["input"]>;
  refreshed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  rss_urls?: InputMaybe<Array<Scalars["String"]["input"]>>;
  scrape_frequency?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  scraped_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type ContentSourcesSumFields = {
  __typename?: "content_sources_sum_fields";
  expected_count?: Maybe<Scalars["smallint"]["output"]>;
  failed_count?: Maybe<Scalars["smallint"]["output"]>;
  hash?: Maybe<Scalars["bigint"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
};

/** order by sum() on columns of table "content_sources" */
export type ContentSourcesSumOrderBy = {
  expected_count?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** update columns of table "content_sources" */
export enum ContentSourcesUpdateColumn {
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CONTENT_TYPE = "content_type",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  EXPECTED_COUNT = "expected_count",
  /** column name */
  FAILED_COUNT = "failed_count",
  /** column name */
  HAS_FAILED = "has_failed",
  /** column name */
  HASH = "hash",
  /** column name */
  ID = "id",
  /** column name */
  PRIORITY = "priority",
  /** column name */
  REFRESHED_AT = "refreshed_at",
  /** column name */
  RSS_URLS = "rss_urls",
  /** column name */
  SCRAPE_FREQUENCY = "scrape_frequency",
  /** column name */
  SCRAPED_AT = "scraped_at",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
}

export type ContentSourcesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<ContentSourcesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<ContentSourcesSetInput>;
  /** filter the rows which have to be updated */
  where: ContentSourcesBoolExp;
};

/** aggregate var_pop on columns */
export type ContentSourcesVarPopFields = {
  __typename?: "content_sources_var_pop_fields";
  expected_count?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  hash?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "content_sources" */
export type ContentSourcesVarPopOrderBy = {
  expected_count?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type ContentSourcesVarSampFields = {
  __typename?: "content_sources_var_samp_fields";
  expected_count?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  hash?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "content_sources" */
export type ContentSourcesVarSampOrderBy = {
  expected_count?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type ContentSourcesVarianceFields = {
  __typename?: "content_sources_variance_fields";
  expected_count?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  hash?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "content_sources" */
export type ContentSourcesVarianceOrderBy = {
  expected_count?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Boolean expression to compare columns of type "content_status". All fields are combined with logical 'AND'. */
export type ContentStatusComparisonExp = {
  _eq?: InputMaybe<Scalars["content_status"]["input"]>;
  _gt?: InputMaybe<Scalars["content_status"]["input"]>;
  _gte?: InputMaybe<Scalars["content_status"]["input"]>;
  _in?: InputMaybe<Array<Scalars["content_status"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["content_status"]["input"]>;
  _lte?: InputMaybe<Scalars["content_status"]["input"]>;
  _neq?: InputMaybe<Scalars["content_status"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["content_status"]["input"]>>;
};

/** columns and relationships of "content_statuses" */
export type ContentStatuses = {
  __typename?: "content_statuses";
  /** An object relationship */
  content: Contents;
  content_id: Scalars["uuid"]["output"];
  content_status: Scalars["content_status"]["output"];
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id: Scalars["uuid"]["output"];
  notes?: Maybe<Scalars["String"]["output"]>;
};

/** aggregated selection of "content_statuses" */
export type ContentStatusesAggregate = {
  __typename?: "content_statuses_aggregate";
  aggregate?: Maybe<ContentStatusesAggregateFields>;
  nodes: Array<ContentStatuses>;
};

export type ContentStatusesAggregateBoolExp = {
  count?: InputMaybe<ContentStatusesAggregateBoolExpCount>;
};

export type ContentStatusesAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<ContentStatusesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ContentStatusesBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "content_statuses" */
export type ContentStatusesAggregateFields = {
  __typename?: "content_statuses_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<ContentStatusesMaxFields>;
  min?: Maybe<ContentStatusesMinFields>;
};

/** aggregate fields of "content_statuses" */
export type ContentStatusesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ContentStatusesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "content_statuses" */
export type ContentStatusesAggregateOrderBy = {
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<ContentStatusesMaxOrderBy>;
  min?: InputMaybe<ContentStatusesMinOrderBy>;
};

/** input type for inserting array relation for remote table "content_statuses" */
export type ContentStatusesArrRelInsertInput = {
  data: Array<ContentStatusesInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<ContentStatusesOnConflict>;
};

/** Boolean expression to filter rows from the table "content_statuses". All fields are combined with a logical 'AND'. */
export type ContentStatusesBoolExp = {
  _and?: InputMaybe<Array<ContentStatusesBoolExp>>;
  _not?: InputMaybe<ContentStatusesBoolExp>;
  _or?: InputMaybe<Array<ContentStatusesBoolExp>>;
  content?: InputMaybe<ContentsBoolExp>;
  content_id?: InputMaybe<UuidComparisonExp>;
  content_status?: InputMaybe<ContentStatusComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  notes?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "content_statuses" */
export enum ContentStatusesConstraint {
  /** unique or primary key constraint on columns "id" */
  CONTENT_STATUSES_PKEY = "content_statuses_pkey",
}

/** input type for inserting data into table "content_statuses" */
export type ContentStatusesInsertInput = {
  content?: InputMaybe<ContentsObjRelInsertInput>;
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  notes?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type ContentStatusesMaxFields = {
  __typename?: "content_statuses_max_fields";
  content_id?: Maybe<Scalars["uuid"]["output"]>;
  content_status?: Maybe<Scalars["content_status"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  notes?: Maybe<Scalars["String"]["output"]>;
};

/** order by max() on columns of table "content_statuses" */
export type ContentStatusesMaxOrderBy = {
  content_id?: InputMaybe<OrderBy>;
  content_status?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  notes?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type ContentStatusesMinFields = {
  __typename?: "content_statuses_min_fields";
  content_id?: Maybe<Scalars["uuid"]["output"]>;
  content_status?: Maybe<Scalars["content_status"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  notes?: Maybe<Scalars["String"]["output"]>;
};

/** order by min() on columns of table "content_statuses" */
export type ContentStatusesMinOrderBy = {
  content_id?: InputMaybe<OrderBy>;
  content_status?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  notes?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "content_statuses" */
export type ContentStatusesMutationResponse = {
  __typename?: "content_statuses_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<ContentStatuses>;
};

/** on_conflict condition type for table "content_statuses" */
export type ContentStatusesOnConflict = {
  constraint: ContentStatusesConstraint;
  update_columns?: Array<ContentStatusesUpdateColumn>;
  where?: InputMaybe<ContentStatusesBoolExp>;
};

/** Ordering options when selecting data from "content_statuses". */
export type ContentStatusesOrderBy = {
  content?: InputMaybe<ContentsOrderBy>;
  content_id?: InputMaybe<OrderBy>;
  content_status?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  notes?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: content_statuses */
export type ContentStatusesPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "content_statuses" */
export enum ContentStatusesSelectColumn {
  /** column name */
  CONTENT_ID = "content_id",
  /** column name */
  CONTENT_STATUS = "content_status",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  NOTES = "notes",
}

/** input type for updating data in table "content_statuses" */
export type ContentStatusesSetInput = {
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  notes?: InputMaybe<Scalars["String"]["input"]>;
};

/** Streaming cursor of the table "content_statuses" */
export type ContentStatusesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ContentStatusesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ContentStatusesStreamCursorValueInput = {
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  notes?: InputMaybe<Scalars["String"]["input"]>;
};

/** update columns of table "content_statuses" */
export enum ContentStatusesUpdateColumn {
  /** column name */
  CONTENT_ID = "content_id",
  /** column name */
  CONTENT_STATUS = "content_status",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  NOTES = "notes",
}

export type ContentStatusesUpdates = {
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<ContentStatusesSetInput>;
  /** filter the rows which have to be updated */
  where: ContentStatusesBoolExp;
};

/** columns and relationships of "content_tags" */
export type ContentTags = {
  __typename?: "content_tags";
  /** An object relationship */
  content: Contents;
  content_id: Scalars["uuid"]["output"];
  /** An object relationship */
  tag: Tags;
  tag_id: Scalars["Int"]["output"];
};

/** aggregated selection of "content_tags" */
export type ContentTagsAggregate = {
  __typename?: "content_tags_aggregate";
  aggregate?: Maybe<ContentTagsAggregateFields>;
  nodes: Array<ContentTags>;
};

export type ContentTagsAggregateBoolExp = {
  count?: InputMaybe<ContentTagsAggregateBoolExpCount>;
};

export type ContentTagsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<ContentTagsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ContentTagsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "content_tags" */
export type ContentTagsAggregateFields = {
  __typename?: "content_tags_aggregate_fields";
  avg?: Maybe<ContentTagsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ContentTagsMaxFields>;
  min?: Maybe<ContentTagsMinFields>;
  stddev?: Maybe<ContentTagsStddevFields>;
  stddev_pop?: Maybe<ContentTagsStddevPopFields>;
  stddev_samp?: Maybe<ContentTagsStddevSampFields>;
  sum?: Maybe<ContentTagsSumFields>;
  var_pop?: Maybe<ContentTagsVarPopFields>;
  var_samp?: Maybe<ContentTagsVarSampFields>;
  variance?: Maybe<ContentTagsVarianceFields>;
};

/** aggregate fields of "content_tags" */
export type ContentTagsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ContentTagsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "content_tags" */
export type ContentTagsAggregateOrderBy = {
  avg?: InputMaybe<ContentTagsAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<ContentTagsMaxOrderBy>;
  min?: InputMaybe<ContentTagsMinOrderBy>;
  stddev?: InputMaybe<ContentTagsStddevOrderBy>;
  stddev_pop?: InputMaybe<ContentTagsStddevPopOrderBy>;
  stddev_samp?: InputMaybe<ContentTagsStddevSampOrderBy>;
  sum?: InputMaybe<ContentTagsSumOrderBy>;
  var_pop?: InputMaybe<ContentTagsVarPopOrderBy>;
  var_samp?: InputMaybe<ContentTagsVarSampOrderBy>;
  variance?: InputMaybe<ContentTagsVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "content_tags" */
export type ContentTagsArrRelInsertInput = {
  data: Array<ContentTagsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<ContentTagsOnConflict>;
};

/** aggregate avg on columns */
export type ContentTagsAvgFields = {
  __typename?: "content_tags_avg_fields";
  tag_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "content_tags" */
export type ContentTagsAvgOrderBy = {
  tag_id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "content_tags". All fields are combined with a logical 'AND'. */
export type ContentTagsBoolExp = {
  _and?: InputMaybe<Array<ContentTagsBoolExp>>;
  _not?: InputMaybe<ContentTagsBoolExp>;
  _or?: InputMaybe<Array<ContentTagsBoolExp>>;
  content?: InputMaybe<ContentsBoolExp>;
  content_id?: InputMaybe<UuidComparisonExp>;
  tag?: InputMaybe<TagsBoolExp>;
  tag_id?: InputMaybe<IntComparisonExp>;
};

/** unique or primary key constraints on table "content_tags" */
export enum ContentTagsConstraint {
  /** unique or primary key constraint on columns "content_id", "tag_id" */
  CONTENT_TAGS_PKEY = "content_tags_pkey",
}

/** input type for incrementing numeric columns in table "content_tags" */
export type ContentTagsIncInput = {
  tag_id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "content_tags" */
export type ContentTagsInsertInput = {
  content?: InputMaybe<ContentsObjRelInsertInput>;
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  tag?: InputMaybe<TagsObjRelInsertInput>;
  tag_id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate max on columns */
export type ContentTagsMaxFields = {
  __typename?: "content_tags_max_fields";
  content_id?: Maybe<Scalars["uuid"]["output"]>;
  tag_id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by max() on columns of table "content_tags" */
export type ContentTagsMaxOrderBy = {
  content_id?: InputMaybe<OrderBy>;
  tag_id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type ContentTagsMinFields = {
  __typename?: "content_tags_min_fields";
  content_id?: Maybe<Scalars["uuid"]["output"]>;
  tag_id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by min() on columns of table "content_tags" */
export type ContentTagsMinOrderBy = {
  content_id?: InputMaybe<OrderBy>;
  tag_id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "content_tags" */
export type ContentTagsMutationResponse = {
  __typename?: "content_tags_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<ContentTags>;
};

/** on_conflict condition type for table "content_tags" */
export type ContentTagsOnConflict = {
  constraint: ContentTagsConstraint;
  update_columns?: Array<ContentTagsUpdateColumn>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

/** Ordering options when selecting data from "content_tags". */
export type ContentTagsOrderBy = {
  content?: InputMaybe<ContentsOrderBy>;
  content_id?: InputMaybe<OrderBy>;
  tag?: InputMaybe<TagsOrderBy>;
  tag_id?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: content_tags */
export type ContentTagsPkColumnsInput = {
  content_id: Scalars["uuid"]["input"];
  tag_id: Scalars["Int"]["input"];
};

/** select columns of table "content_tags" */
export enum ContentTagsSelectColumn {
  /** column name */
  CONTENT_ID = "content_id",
  /** column name */
  TAG_ID = "tag_id",
}

/** input type for updating data in table "content_tags" */
export type ContentTagsSetInput = {
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  tag_id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate stddev on columns */
export type ContentTagsStddevFields = {
  __typename?: "content_tags_stddev_fields";
  tag_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "content_tags" */
export type ContentTagsStddevOrderBy = {
  tag_id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type ContentTagsStddevPopFields = {
  __typename?: "content_tags_stddev_pop_fields";
  tag_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "content_tags" */
export type ContentTagsStddevPopOrderBy = {
  tag_id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type ContentTagsStddevSampFields = {
  __typename?: "content_tags_stddev_samp_fields";
  tag_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "content_tags" */
export type ContentTagsStddevSampOrderBy = {
  tag_id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "content_tags" */
export type ContentTagsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ContentTagsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ContentTagsStreamCursorValueInput = {
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  tag_id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate sum on columns */
export type ContentTagsSumFields = {
  __typename?: "content_tags_sum_fields";
  tag_id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "content_tags" */
export type ContentTagsSumOrderBy = {
  tag_id?: InputMaybe<OrderBy>;
};

/** update columns of table "content_tags" */
export enum ContentTagsUpdateColumn {
  /** column name */
  CONTENT_ID = "content_id",
  /** column name */
  TAG_ID = "tag_id",
}

export type ContentTagsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<ContentTagsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<ContentTagsSetInput>;
  /** filter the rows which have to be updated */
  where: ContentTagsBoolExp;
};

/** aggregate var_pop on columns */
export type ContentTagsVarPopFields = {
  __typename?: "content_tags_var_pop_fields";
  tag_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "content_tags" */
export type ContentTagsVarPopOrderBy = {
  tag_id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type ContentTagsVarSampFields = {
  __typename?: "content_tags_var_samp_fields";
  tag_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "content_tags" */
export type ContentTagsVarSampOrderBy = {
  tag_id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type ContentTagsVarianceFields = {
  __typename?: "content_tags_variance_fields";
  tag_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "content_tags" */
export type ContentTagsVarianceOrderBy = {
  tag_id?: InputMaybe<OrderBy>;
};

/** Boolean expression to compare columns of type "content_type". All fields are combined with logical 'AND'. */
export type ContentTypeComparisonExp = {
  _eq?: InputMaybe<Scalars["content_type"]["input"]>;
  _gt?: InputMaybe<Scalars["content_type"]["input"]>;
  _gte?: InputMaybe<Scalars["content_type"]["input"]>;
  _in?: InputMaybe<Array<Scalars["content_type"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["content_type"]["input"]>;
  _lte?: InputMaybe<Scalars["content_type"]["input"]>;
  _neq?: InputMaybe<Scalars["content_type"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["content_type"]["input"]>>;
};

/** columns and relationships of "contents" */
export type Contents = {
  __typename?: "contents";
  /** An array relationship */
  bookmarks: Array<Bookmarks>;
  /** An aggregate relationship */
  bookmarks_aggregate: BookmarksAggregate;
  /** An array relationship */
  content_categories: Array<ContentCategories>;
  /** An aggregate relationship */
  content_categories_aggregate: ContentCategoriesAggregate;
  /** An array relationship */
  content_source_visits: Array<ContentSourceVisits>;
  /** An aggregate relationship */
  content_source_visits_aggregate: ContentSourceVisitsAggregate;
  /** An array relationship */
  content_statuses: Array<ContentStatuses>;
  /** An aggregate relationship */
  content_statuses_aggregate: ContentStatusesAggregate;
  /** An array relationship */
  content_tags: Array<ContentTags>;
  /** An aggregate relationship */
  content_tags_aggregate: ContentTagsAggregate;
  content_type: Scalars["content_type"]["output"];
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  hot_score?: Maybe<Scalars["float8"]["output"]>;
  id: Scalars["uuid"]["output"];
  /** An object relationship */
  news?: Maybe<News>;
  /** An object relationship */
  newsletter?: Maybe<Newsletters>;
  /** An object relationship */
  research?: Maybe<Research>;
  rss_url?: Maybe<Scalars["String"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url: Scalars["String"]["output"];
};

/** columns and relationships of "contents" */
export type ContentsBookmarksArgs = {
  distinct_on?: InputMaybe<Array<BookmarksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarksOrderBy>>;
  where?: InputMaybe<BookmarksBoolExp>;
};

/** columns and relationships of "contents" */
export type ContentsBookmarksAggregateArgs = {
  distinct_on?: InputMaybe<Array<BookmarksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarksOrderBy>>;
  where?: InputMaybe<BookmarksBoolExp>;
};

/** columns and relationships of "contents" */
export type ContentsContentCategoriesArgs = {
  distinct_on?: InputMaybe<Array<ContentCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentCategoriesOrderBy>>;
  where?: InputMaybe<ContentCategoriesBoolExp>;
};

/** columns and relationships of "contents" */
export type ContentsContentCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentCategoriesOrderBy>>;
  where?: InputMaybe<ContentCategoriesBoolExp>;
};

/** columns and relationships of "contents" */
export type ContentsContentSourceVisitsArgs = {
  distinct_on?: InputMaybe<Array<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

/** columns and relationships of "contents" */
export type ContentsContentSourceVisitsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

/** columns and relationships of "contents" */
export type ContentsContentStatusesArgs = {
  distinct_on?: InputMaybe<Array<ContentStatusesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentStatusesOrderBy>>;
  where?: InputMaybe<ContentStatusesBoolExp>;
};

/** columns and relationships of "contents" */
export type ContentsContentStatusesAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentStatusesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentStatusesOrderBy>>;
  where?: InputMaybe<ContentStatusesBoolExp>;
};

/** columns and relationships of "contents" */
export type ContentsContentTagsArgs = {
  distinct_on?: InputMaybe<Array<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentTagsOrderBy>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

/** columns and relationships of "contents" */
export type ContentsContentTagsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentTagsOrderBy>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

/** aggregated selection of "contents" */
export type ContentsAggregate = {
  __typename?: "contents_aggregate";
  aggregate?: Maybe<ContentsAggregateFields>;
  nodes: Array<Contents>;
};

/** aggregate fields of "contents" */
export type ContentsAggregateFields = {
  __typename?: "contents_aggregate_fields";
  avg?: Maybe<ContentsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ContentsMaxFields>;
  min?: Maybe<ContentsMinFields>;
  stddev?: Maybe<ContentsStddevFields>;
  stddev_pop?: Maybe<ContentsStddevPopFields>;
  stddev_samp?: Maybe<ContentsStddevSampFields>;
  sum?: Maybe<ContentsSumFields>;
  var_pop?: Maybe<ContentsVarPopFields>;
  var_samp?: Maybe<ContentsVarSampFields>;
  variance?: Maybe<ContentsVarianceFields>;
};

/** aggregate fields of "contents" */
export type ContentsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ContentsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type ContentsAvgFields = {
  __typename?: "contents_avg_fields";
  hot_score?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "contents". All fields are combined with a logical 'AND'. */
export type ContentsBoolExp = {
  _and?: InputMaybe<Array<ContentsBoolExp>>;
  _not?: InputMaybe<ContentsBoolExp>;
  _or?: InputMaybe<Array<ContentsBoolExp>>;
  bookmarks?: InputMaybe<BookmarksBoolExp>;
  bookmarks_aggregate?: InputMaybe<BookmarksAggregateBoolExp>;
  content_categories?: InputMaybe<ContentCategoriesBoolExp>;
  content_categories_aggregate?: InputMaybe<ContentCategoriesAggregateBoolExp>;
  content_source_visits?: InputMaybe<ContentSourceVisitsBoolExp>;
  content_source_visits_aggregate?: InputMaybe<ContentSourceVisitsAggregateBoolExp>;
  content_statuses?: InputMaybe<ContentStatusesBoolExp>;
  content_statuses_aggregate?: InputMaybe<ContentStatusesAggregateBoolExp>;
  content_tags?: InputMaybe<ContentTagsBoolExp>;
  content_tags_aggregate?: InputMaybe<ContentTagsAggregateBoolExp>;
  content_type?: InputMaybe<ContentTypeComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  hot_score?: InputMaybe<Float8ComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  news?: InputMaybe<NewsBoolExp>;
  newsletter?: InputMaybe<NewslettersBoolExp>;
  research?: InputMaybe<ResearchBoolExp>;
  rss_url?: InputMaybe<StringComparisonExp>;
  title?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  url?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "contents" */
export enum ContentsConstraint {
  /** unique or primary key constraint on columns "id" */
  CONTENTS_PKEY = "contents_pkey",
  /** unique or primary key constraint on columns "url" */
  CONTENTS_URL_KEY = "contents_url_key",
}

/** input type for incrementing numeric columns in table "contents" */
export type ContentsIncInput = {
  hot_score?: InputMaybe<Scalars["float8"]["input"]>;
};

/** input type for inserting data into table "contents" */
export type ContentsInsertInput = {
  bookmarks?: InputMaybe<BookmarksArrRelInsertInput>;
  content_categories?: InputMaybe<ContentCategoriesArrRelInsertInput>;
  content_source_visits?: InputMaybe<ContentSourceVisitsArrRelInsertInput>;
  content_statuses?: InputMaybe<ContentStatusesArrRelInsertInput>;
  content_tags?: InputMaybe<ContentTagsArrRelInsertInput>;
  content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  hot_score?: InputMaybe<Scalars["float8"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  news?: InputMaybe<NewsObjRelInsertInput>;
  newsletter?: InputMaybe<NewslettersObjRelInsertInput>;
  research?: InputMaybe<ResearchObjRelInsertInput>;
  rss_url?: InputMaybe<Scalars["String"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type ContentsMaxFields = {
  __typename?: "contents_max_fields";
  content_type?: Maybe<Scalars["content_type"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  hot_score?: Maybe<Scalars["float8"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  rss_url?: Maybe<Scalars["String"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** aggregate min on columns */
export type ContentsMinFields = {
  __typename?: "contents_min_fields";
  content_type?: Maybe<Scalars["content_type"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  hot_score?: Maybe<Scalars["float8"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  rss_url?: Maybe<Scalars["String"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** response of any mutation on the table "contents" */
export type ContentsMutationResponse = {
  __typename?: "contents_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Contents>;
};

/** input type for inserting object relation for remote table "contents" */
export type ContentsObjRelInsertInput = {
  data: ContentsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<ContentsOnConflict>;
};

/** on_conflict condition type for table "contents" */
export type ContentsOnConflict = {
  constraint: ContentsConstraint;
  update_columns?: Array<ContentsUpdateColumn>;
  where?: InputMaybe<ContentsBoolExp>;
};

/** Ordering options when selecting data from "contents". */
export type ContentsOrderBy = {
  bookmarks_aggregate?: InputMaybe<BookmarksAggregateOrderBy>;
  content_categories_aggregate?: InputMaybe<ContentCategoriesAggregateOrderBy>;
  content_source_visits_aggregate?: InputMaybe<ContentSourceVisitsAggregateOrderBy>;
  content_statuses_aggregate?: InputMaybe<ContentStatusesAggregateOrderBy>;
  content_tags_aggregate?: InputMaybe<ContentTagsAggregateOrderBy>;
  content_type?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  hot_score?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  news?: InputMaybe<NewsOrderBy>;
  newsletter?: InputMaybe<NewslettersOrderBy>;
  research?: InputMaybe<ResearchOrderBy>;
  rss_url?: InputMaybe<OrderBy>;
  title?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: contents */
export type ContentsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "contents" */
export enum ContentsSelectColumn {
  /** column name */
  CONTENT_TYPE = "content_type",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  HOT_SCORE = "hot_score",
  /** column name */
  ID = "id",
  /** column name */
  RSS_URL = "rss_url",
  /** column name */
  TITLE = "title",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
}

/** input type for updating data in table "contents" */
export type ContentsSetInput = {
  content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  hot_score?: InputMaybe<Scalars["float8"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  rss_url?: InputMaybe<Scalars["String"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type ContentsStddevFields = {
  __typename?: "contents_stddev_fields";
  hot_score?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type ContentsStddevPopFields = {
  __typename?: "contents_stddev_pop_fields";
  hot_score?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type ContentsStddevSampFields = {
  __typename?: "contents_stddev_samp_fields";
  hot_score?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "contents" */
export type ContentsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ContentsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ContentsStreamCursorValueInput = {
  content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  hot_score?: InputMaybe<Scalars["float8"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  rss_url?: InputMaybe<Scalars["String"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type ContentsSumFields = {
  __typename?: "contents_sum_fields";
  hot_score?: Maybe<Scalars["float8"]["output"]>;
};

/** update columns of table "contents" */
export enum ContentsUpdateColumn {
  /** column name */
  CONTENT_TYPE = "content_type",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  HOT_SCORE = "hot_score",
  /** column name */
  ID = "id",
  /** column name */
  RSS_URL = "rss_url",
  /** column name */
  TITLE = "title",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
}

export type ContentsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<ContentsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<ContentsSetInput>;
  /** filter the rows which have to be updated */
  where: ContentsBoolExp;
};

/** aggregate var_pop on columns */
export type ContentsVarPopFields = {
  __typename?: "contents_var_pop_fields";
  hot_score?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type ContentsVarSampFields = {
  __typename?: "contents_var_samp_fields";
  hot_score?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type ContentsVarianceFields = {
  __typename?: "contents_variance_fields";
  hot_score?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "countries" */
export type Countries = {
  __typename?: "countries";
  /** An array relationship */
  addresses: Array<Addresses>;
  /** An aggregate relationship */
  addresses_aggregate: AddressesAggregate;
  /** An array relationship */
  cities: Array<Cities>;
  /** An aggregate relationship */
  cities_aggregate: CitiesAggregate;
  code: Scalars["String"]["output"];
  code_3?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["Int"]["output"];
  name: Scalars["String"]["output"];
};

/** columns and relationships of "countries" */
export type CountriesAddressesArgs = {
  distinct_on?: InputMaybe<Array<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

/** columns and relationships of "countries" */
export type CountriesAddressesAggregateArgs = {
  distinct_on?: InputMaybe<Array<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

/** columns and relationships of "countries" */
export type CountriesCitiesArgs = {
  distinct_on?: InputMaybe<Array<CitiesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CitiesOrderBy>>;
  where?: InputMaybe<CitiesBoolExp>;
};

/** columns and relationships of "countries" */
export type CountriesCitiesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CitiesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CitiesOrderBy>>;
  where?: InputMaybe<CitiesBoolExp>;
};

/** aggregated selection of "countries" */
export type CountriesAggregate = {
  __typename?: "countries_aggregate";
  aggregate?: Maybe<CountriesAggregateFields>;
  nodes: Array<Countries>;
};

/** aggregate fields of "countries" */
export type CountriesAggregateFields = {
  __typename?: "countries_aggregate_fields";
  avg?: Maybe<CountriesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<CountriesMaxFields>;
  min?: Maybe<CountriesMinFields>;
  stddev?: Maybe<CountriesStddevFields>;
  stddev_pop?: Maybe<CountriesStddevPopFields>;
  stddev_samp?: Maybe<CountriesStddevSampFields>;
  sum?: Maybe<CountriesSumFields>;
  var_pop?: Maybe<CountriesVarPopFields>;
  var_samp?: Maybe<CountriesVarSampFields>;
  variance?: Maybe<CountriesVarianceFields>;
};

/** aggregate fields of "countries" */
export type CountriesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CountriesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type CountriesAvgFields = {
  __typename?: "countries_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "countries". All fields are combined with a logical 'AND'. */
export type CountriesBoolExp = {
  _and?: InputMaybe<Array<CountriesBoolExp>>;
  _not?: InputMaybe<CountriesBoolExp>;
  _or?: InputMaybe<Array<CountriesBoolExp>>;
  addresses?: InputMaybe<AddressesBoolExp>;
  addresses_aggregate?: InputMaybe<AddressesAggregateBoolExp>;
  cities?: InputMaybe<CitiesBoolExp>;
  cities_aggregate?: InputMaybe<CitiesAggregateBoolExp>;
  code?: InputMaybe<StringComparisonExp>;
  code_3?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "countries" */
export enum CountriesConstraint {
  /** unique or primary key constraint on columns "name" */
  COUNTRIES_NAME_KEY = "countries_name_key",
  /** unique or primary key constraint on columns "id" */
  COUNTRIES_PKEY = "countries_pkey",
}

/** input type for incrementing numeric columns in table "countries" */
export type CountriesIncInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "countries" */
export type CountriesInsertInput = {
  addresses?: InputMaybe<AddressesArrRelInsertInput>;
  cities?: InputMaybe<CitiesArrRelInsertInput>;
  code?: InputMaybe<Scalars["String"]["input"]>;
  code_3?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type CountriesMaxFields = {
  __typename?: "countries_max_fields";
  code?: Maybe<Scalars["String"]["output"]>;
  code_3?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
};

/** aggregate min on columns */
export type CountriesMinFields = {
  __typename?: "countries_min_fields";
  code?: Maybe<Scalars["String"]["output"]>;
  code_3?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
};

/** response of any mutation on the table "countries" */
export type CountriesMutationResponse = {
  __typename?: "countries_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Countries>;
};

/** input type for inserting object relation for remote table "countries" */
export type CountriesObjRelInsertInput = {
  data: CountriesInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<CountriesOnConflict>;
};

/** on_conflict condition type for table "countries" */
export type CountriesOnConflict = {
  constraint: CountriesConstraint;
  update_columns?: Array<CountriesUpdateColumn>;
  where?: InputMaybe<CountriesBoolExp>;
};

/** Ordering options when selecting data from "countries". */
export type CountriesOrderBy = {
  addresses_aggregate?: InputMaybe<AddressesAggregateOrderBy>;
  cities_aggregate?: InputMaybe<CitiesAggregateOrderBy>;
  code?: InputMaybe<OrderBy>;
  code_3?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: countries */
export type CountriesPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "countries" */
export enum CountriesSelectColumn {
  /** column name */
  CODE = "code",
  /** column name */
  CODE_3 = "code_3",
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
}

/** input type for updating data in table "countries" */
export type CountriesSetInput = {
  code?: InputMaybe<Scalars["String"]["input"]>;
  code_3?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type CountriesStddevFields = {
  __typename?: "countries_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type CountriesStddevPopFields = {
  __typename?: "countries_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type CountriesStddevSampFields = {
  __typename?: "countries_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "countries" */
export type CountriesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CountriesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CountriesStreamCursorValueInput = {
  code?: InputMaybe<Scalars["String"]["input"]>;
  code_3?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type CountriesSumFields = {
  __typename?: "countries_sum_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "countries" */
export enum CountriesUpdateColumn {
  /** column name */
  CODE = "code",
  /** column name */
  CODE_3 = "code_3",
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
}

export type CountriesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<CountriesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CountriesSetInput>;
  /** filter the rows which have to be updated */
  where: CountriesBoolExp;
};

/** aggregate var_pop on columns */
export type CountriesVarPopFields = {
  __typename?: "countries_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type CountriesVarSampFields = {
  __typename?: "countries_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type CountriesVarianceFields = {
  __typename?: "countries_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** ordering argument of a cursor */
export enum CursorOrdering {
  /** ascending ordering of the cursor */
  ASC = "ASC",
  /** descending ordering of the cursor */
  DESC = "DESC",
}

/** columns and relationships of "customer_payments" */
export type CustomerPayments = {
  __typename?: "customer_payments";
  acquirer_data?: Maybe<Scalars["jsonb"]["output"]>;
  amount: Scalars["numeric"]["output"];
  amount_refunded?: Maybe<Scalars["numeric"]["output"]>;
  amount_transferred?: Maybe<Scalars["numeric"]["output"]>;
  bank?: Maybe<Scalars["String"]["output"]>;
  captured?: Maybe<Scalars["Boolean"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  currency: Scalars["String"]["output"];
  /** An array relationship */
  customer_refunds: Array<CustomerRefunds>;
  /** An aggregate relationship */
  customer_refunds_aggregate: CustomerRefundsAggregate;
  /** An object relationship */
  customer_subscription?: Maybe<CustomerSubscriptions>;
  description?: Maybe<Scalars["String"]["output"]>;
  error_code?: Maybe<Scalars["String"]["output"]>;
  error_description?: Maybe<Scalars["String"]["output"]>;
  error_reason?: Maybe<Scalars["String"]["output"]>;
  error_source?: Maybe<Scalars["String"]["output"]>;
  error_step?: Maybe<Scalars["String"]["output"]>;
  external_order_id?: Maybe<Scalars["String"]["output"]>;
  external_payment_id: Scalars["String"]["output"];
  fee?: Maybe<Scalars["numeric"]["output"]>;
  id: Scalars["Int"]["output"];
  international?: Maybe<Scalars["Boolean"]["output"]>;
  invoice_id?: Maybe<Scalars["String"]["output"]>;
  method?: Maybe<Scalars["String"]["output"]>;
  notes?: Maybe<Scalars["jsonb"]["output"]>;
  order_id?: Maybe<Scalars["String"]["output"]>;
  /** An object relationship */
  payment_provider: PaymentProviders;
  payment_provider_id: Scalars["Int"]["output"];
  refund_status?: Maybe<Scalars["String"]["output"]>;
  status: Scalars["String"]["output"];
  subscription_id?: Maybe<Scalars["Int"]["output"]>;
  tax?: Maybe<Scalars["numeric"]["output"]>;
  user_id: Scalars["uuid"]["output"];
  /** An object relationship */
  user_profile: UserProfiles;
  vpa?: Maybe<Scalars["String"]["output"]>;
  wallet?: Maybe<Scalars["String"]["output"]>;
};

/** columns and relationships of "customer_payments" */
export type CustomerPaymentsAcquirerDataArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "customer_payments" */
export type CustomerPaymentsCustomerRefundsArgs = {
  distinct_on?: InputMaybe<Array<CustomerRefundsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerRefundsOrderBy>>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
};

/** columns and relationships of "customer_payments" */
export type CustomerPaymentsCustomerRefundsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerRefundsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerRefundsOrderBy>>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
};

/** columns and relationships of "customer_payments" */
export type CustomerPaymentsNotesArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "customer_payments" */
export type CustomerPaymentsAggregate = {
  __typename?: "customer_payments_aggregate";
  aggregate?: Maybe<CustomerPaymentsAggregateFields>;
  nodes: Array<CustomerPayments>;
};

export type CustomerPaymentsAggregateBoolExp = {
  bool_and?: InputMaybe<CustomerPaymentsAggregateBoolExpBoolAnd>;
  bool_or?: InputMaybe<CustomerPaymentsAggregateBoolExpBoolOr>;
  count?: InputMaybe<CustomerPaymentsAggregateBoolExpCount>;
};

export type CustomerPaymentsAggregateBoolExpBoolAnd = {
  arguments: CustomerPaymentsSelectColumnCustomerPaymentsAggregateBoolExpBoolAndArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CustomerPaymentsBoolExp>;
  predicate: BooleanComparisonExp;
};

export type CustomerPaymentsAggregateBoolExpBoolOr = {
  arguments: CustomerPaymentsSelectColumnCustomerPaymentsAggregateBoolExpBoolOrArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CustomerPaymentsBoolExp>;
  predicate: BooleanComparisonExp;
};

export type CustomerPaymentsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<CustomerPaymentsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CustomerPaymentsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "customer_payments" */
export type CustomerPaymentsAggregateFields = {
  __typename?: "customer_payments_aggregate_fields";
  avg?: Maybe<CustomerPaymentsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<CustomerPaymentsMaxFields>;
  min?: Maybe<CustomerPaymentsMinFields>;
  stddev?: Maybe<CustomerPaymentsStddevFields>;
  stddev_pop?: Maybe<CustomerPaymentsStddevPopFields>;
  stddev_samp?: Maybe<CustomerPaymentsStddevSampFields>;
  sum?: Maybe<CustomerPaymentsSumFields>;
  var_pop?: Maybe<CustomerPaymentsVarPopFields>;
  var_samp?: Maybe<CustomerPaymentsVarSampFields>;
  variance?: Maybe<CustomerPaymentsVarianceFields>;
};

/** aggregate fields of "customer_payments" */
export type CustomerPaymentsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CustomerPaymentsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "customer_payments" */
export type CustomerPaymentsAggregateOrderBy = {
  avg?: InputMaybe<CustomerPaymentsAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<CustomerPaymentsMaxOrderBy>;
  min?: InputMaybe<CustomerPaymentsMinOrderBy>;
  stddev?: InputMaybe<CustomerPaymentsStddevOrderBy>;
  stddev_pop?: InputMaybe<CustomerPaymentsStddevPopOrderBy>;
  stddev_samp?: InputMaybe<CustomerPaymentsStddevSampOrderBy>;
  sum?: InputMaybe<CustomerPaymentsSumOrderBy>;
  var_pop?: InputMaybe<CustomerPaymentsVarPopOrderBy>;
  var_samp?: InputMaybe<CustomerPaymentsVarSampOrderBy>;
  variance?: InputMaybe<CustomerPaymentsVarianceOrderBy>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type CustomerPaymentsAppendInput = {
  acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  notes?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** input type for inserting array relation for remote table "customer_payments" */
export type CustomerPaymentsArrRelInsertInput = {
  data: Array<CustomerPaymentsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<CustomerPaymentsOnConflict>;
};

/** aggregate avg on columns */
export type CustomerPaymentsAvgFields = {
  __typename?: "customer_payments_avg_fields";
  amount?: Maybe<Scalars["Float"]["output"]>;
  amount_refunded?: Maybe<Scalars["Float"]["output"]>;
  amount_transferred?: Maybe<Scalars["Float"]["output"]>;
  fee?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  subscription_id?: Maybe<Scalars["Float"]["output"]>;
  tax?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "customer_payments" */
export type CustomerPaymentsAvgOrderBy = {
  amount?: InputMaybe<OrderBy>;
  amount_refunded?: InputMaybe<OrderBy>;
  amount_transferred?: InputMaybe<OrderBy>;
  fee?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  subscription_id?: InputMaybe<OrderBy>;
  tax?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "customer_payments". All fields are combined with a logical 'AND'. */
export type CustomerPaymentsBoolExp = {
  _and?: InputMaybe<Array<CustomerPaymentsBoolExp>>;
  _not?: InputMaybe<CustomerPaymentsBoolExp>;
  _or?: InputMaybe<Array<CustomerPaymentsBoolExp>>;
  acquirer_data?: InputMaybe<JsonbComparisonExp>;
  amount?: InputMaybe<NumericComparisonExp>;
  amount_refunded?: InputMaybe<NumericComparisonExp>;
  amount_transferred?: InputMaybe<NumericComparisonExp>;
  bank?: InputMaybe<StringComparisonExp>;
  captured?: InputMaybe<BooleanComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  currency?: InputMaybe<StringComparisonExp>;
  customer_refunds?: InputMaybe<CustomerRefundsBoolExp>;
  customer_refunds_aggregate?: InputMaybe<CustomerRefundsAggregateBoolExp>;
  customer_subscription?: InputMaybe<CustomerSubscriptionsBoolExp>;
  description?: InputMaybe<StringComparisonExp>;
  error_code?: InputMaybe<StringComparisonExp>;
  error_description?: InputMaybe<StringComparisonExp>;
  error_reason?: InputMaybe<StringComparisonExp>;
  error_source?: InputMaybe<StringComparisonExp>;
  error_step?: InputMaybe<StringComparisonExp>;
  external_order_id?: InputMaybe<StringComparisonExp>;
  external_payment_id?: InputMaybe<StringComparisonExp>;
  fee?: InputMaybe<NumericComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  international?: InputMaybe<BooleanComparisonExp>;
  invoice_id?: InputMaybe<StringComparisonExp>;
  method?: InputMaybe<StringComparisonExp>;
  notes?: InputMaybe<JsonbComparisonExp>;
  order_id?: InputMaybe<StringComparisonExp>;
  payment_provider?: InputMaybe<PaymentProvidersBoolExp>;
  payment_provider_id?: InputMaybe<IntComparisonExp>;
  refund_status?: InputMaybe<StringComparisonExp>;
  status?: InputMaybe<StringComparisonExp>;
  subscription_id?: InputMaybe<IntComparisonExp>;
  tax?: InputMaybe<NumericComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
  user_profile?: InputMaybe<UserProfilesBoolExp>;
  vpa?: InputMaybe<StringComparisonExp>;
  wallet?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "customer_payments" */
export enum CustomerPaymentsConstraint {
  /** unique or primary key constraint on columns "id" */
  CUSTOMER_PAYMENTS_PKEY = "customer_payments_pkey",
  /** unique or primary key constraint on columns "external_payment_id" */
  UQ_PAYMENT_ID = "uq_payment_id",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type CustomerPaymentsDeleteAtPathInput = {
  acquirer_data?: InputMaybe<Array<Scalars["String"]["input"]>>;
  notes?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type CustomerPaymentsDeleteElemInput = {
  acquirer_data?: InputMaybe<Scalars["Int"]["input"]>;
  notes?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type CustomerPaymentsDeleteKeyInput = {
  acquirer_data?: InputMaybe<Scalars["String"]["input"]>;
  notes?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for incrementing numeric columns in table "customer_payments" */
export type CustomerPaymentsIncInput = {
  amount?: InputMaybe<Scalars["numeric"]["input"]>;
  amount_refunded?: InputMaybe<Scalars["numeric"]["input"]>;
  amount_transferred?: InputMaybe<Scalars["numeric"]["input"]>;
  fee?: InputMaybe<Scalars["numeric"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  subscription_id?: InputMaybe<Scalars["Int"]["input"]>;
  tax?: InputMaybe<Scalars["numeric"]["input"]>;
};

/** input type for inserting data into table "customer_payments" */
export type CustomerPaymentsInsertInput = {
  acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  amount?: InputMaybe<Scalars["numeric"]["input"]>;
  amount_refunded?: InputMaybe<Scalars["numeric"]["input"]>;
  amount_transferred?: InputMaybe<Scalars["numeric"]["input"]>;
  bank?: InputMaybe<Scalars["String"]["input"]>;
  captured?: InputMaybe<Scalars["Boolean"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  currency?: InputMaybe<Scalars["String"]["input"]>;
  customer_refunds?: InputMaybe<CustomerRefundsArrRelInsertInput>;
  customer_subscription?: InputMaybe<CustomerSubscriptionsObjRelInsertInput>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  error_code?: InputMaybe<Scalars["String"]["input"]>;
  error_description?: InputMaybe<Scalars["String"]["input"]>;
  error_reason?: InputMaybe<Scalars["String"]["input"]>;
  error_source?: InputMaybe<Scalars["String"]["input"]>;
  error_step?: InputMaybe<Scalars["String"]["input"]>;
  external_order_id?: InputMaybe<Scalars["String"]["input"]>;
  external_payment_id?: InputMaybe<Scalars["String"]["input"]>;
  fee?: InputMaybe<Scalars["numeric"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  international?: InputMaybe<Scalars["Boolean"]["input"]>;
  invoice_id?: InputMaybe<Scalars["String"]["input"]>;
  method?: InputMaybe<Scalars["String"]["input"]>;
  notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  order_id?: InputMaybe<Scalars["String"]["input"]>;
  payment_provider?: InputMaybe<PaymentProvidersObjRelInsertInput>;
  payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  refund_status?: InputMaybe<Scalars["String"]["input"]>;
  status?: InputMaybe<Scalars["String"]["input"]>;
  subscription_id?: InputMaybe<Scalars["Int"]["input"]>;
  tax?: InputMaybe<Scalars["numeric"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
  vpa?: InputMaybe<Scalars["String"]["input"]>;
  wallet?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type CustomerPaymentsMaxFields = {
  __typename?: "customer_payments_max_fields";
  amount?: Maybe<Scalars["numeric"]["output"]>;
  amount_refunded?: Maybe<Scalars["numeric"]["output"]>;
  amount_transferred?: Maybe<Scalars["numeric"]["output"]>;
  bank?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  currency?: Maybe<Scalars["String"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  error_code?: Maybe<Scalars["String"]["output"]>;
  error_description?: Maybe<Scalars["String"]["output"]>;
  error_reason?: Maybe<Scalars["String"]["output"]>;
  error_source?: Maybe<Scalars["String"]["output"]>;
  error_step?: Maybe<Scalars["String"]["output"]>;
  external_order_id?: Maybe<Scalars["String"]["output"]>;
  external_payment_id?: Maybe<Scalars["String"]["output"]>;
  fee?: Maybe<Scalars["numeric"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  invoice_id?: Maybe<Scalars["String"]["output"]>;
  method?: Maybe<Scalars["String"]["output"]>;
  order_id?: Maybe<Scalars["String"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Int"]["output"]>;
  refund_status?: Maybe<Scalars["String"]["output"]>;
  status?: Maybe<Scalars["String"]["output"]>;
  subscription_id?: Maybe<Scalars["Int"]["output"]>;
  tax?: Maybe<Scalars["numeric"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
  vpa?: Maybe<Scalars["String"]["output"]>;
  wallet?: Maybe<Scalars["String"]["output"]>;
};

/** order by max() on columns of table "customer_payments" */
export type CustomerPaymentsMaxOrderBy = {
  amount?: InputMaybe<OrderBy>;
  amount_refunded?: InputMaybe<OrderBy>;
  amount_transferred?: InputMaybe<OrderBy>;
  bank?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  currency?: InputMaybe<OrderBy>;
  description?: InputMaybe<OrderBy>;
  error_code?: InputMaybe<OrderBy>;
  error_description?: InputMaybe<OrderBy>;
  error_reason?: InputMaybe<OrderBy>;
  error_source?: InputMaybe<OrderBy>;
  error_step?: InputMaybe<OrderBy>;
  external_order_id?: InputMaybe<OrderBy>;
  external_payment_id?: InputMaybe<OrderBy>;
  fee?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  invoice_id?: InputMaybe<OrderBy>;
  method?: InputMaybe<OrderBy>;
  order_id?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  refund_status?: InputMaybe<OrderBy>;
  status?: InputMaybe<OrderBy>;
  subscription_id?: InputMaybe<OrderBy>;
  tax?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  vpa?: InputMaybe<OrderBy>;
  wallet?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type CustomerPaymentsMinFields = {
  __typename?: "customer_payments_min_fields";
  amount?: Maybe<Scalars["numeric"]["output"]>;
  amount_refunded?: Maybe<Scalars["numeric"]["output"]>;
  amount_transferred?: Maybe<Scalars["numeric"]["output"]>;
  bank?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  currency?: Maybe<Scalars["String"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  error_code?: Maybe<Scalars["String"]["output"]>;
  error_description?: Maybe<Scalars["String"]["output"]>;
  error_reason?: Maybe<Scalars["String"]["output"]>;
  error_source?: Maybe<Scalars["String"]["output"]>;
  error_step?: Maybe<Scalars["String"]["output"]>;
  external_order_id?: Maybe<Scalars["String"]["output"]>;
  external_payment_id?: Maybe<Scalars["String"]["output"]>;
  fee?: Maybe<Scalars["numeric"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  invoice_id?: Maybe<Scalars["String"]["output"]>;
  method?: Maybe<Scalars["String"]["output"]>;
  order_id?: Maybe<Scalars["String"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Int"]["output"]>;
  refund_status?: Maybe<Scalars["String"]["output"]>;
  status?: Maybe<Scalars["String"]["output"]>;
  subscription_id?: Maybe<Scalars["Int"]["output"]>;
  tax?: Maybe<Scalars["numeric"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
  vpa?: Maybe<Scalars["String"]["output"]>;
  wallet?: Maybe<Scalars["String"]["output"]>;
};

/** order by min() on columns of table "customer_payments" */
export type CustomerPaymentsMinOrderBy = {
  amount?: InputMaybe<OrderBy>;
  amount_refunded?: InputMaybe<OrderBy>;
  amount_transferred?: InputMaybe<OrderBy>;
  bank?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  currency?: InputMaybe<OrderBy>;
  description?: InputMaybe<OrderBy>;
  error_code?: InputMaybe<OrderBy>;
  error_description?: InputMaybe<OrderBy>;
  error_reason?: InputMaybe<OrderBy>;
  error_source?: InputMaybe<OrderBy>;
  error_step?: InputMaybe<OrderBy>;
  external_order_id?: InputMaybe<OrderBy>;
  external_payment_id?: InputMaybe<OrderBy>;
  fee?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  invoice_id?: InputMaybe<OrderBy>;
  method?: InputMaybe<OrderBy>;
  order_id?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  refund_status?: InputMaybe<OrderBy>;
  status?: InputMaybe<OrderBy>;
  subscription_id?: InputMaybe<OrderBy>;
  tax?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  vpa?: InputMaybe<OrderBy>;
  wallet?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "customer_payments" */
export type CustomerPaymentsMutationResponse = {
  __typename?: "customer_payments_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<CustomerPayments>;
};

/** input type for inserting object relation for remote table "customer_payments" */
export type CustomerPaymentsObjRelInsertInput = {
  data: CustomerPaymentsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<CustomerPaymentsOnConflict>;
};

/** on_conflict condition type for table "customer_payments" */
export type CustomerPaymentsOnConflict = {
  constraint: CustomerPaymentsConstraint;
  update_columns?: Array<CustomerPaymentsUpdateColumn>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

/** Ordering options when selecting data from "customer_payments". */
export type CustomerPaymentsOrderBy = {
  acquirer_data?: InputMaybe<OrderBy>;
  amount?: InputMaybe<OrderBy>;
  amount_refunded?: InputMaybe<OrderBy>;
  amount_transferred?: InputMaybe<OrderBy>;
  bank?: InputMaybe<OrderBy>;
  captured?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  currency?: InputMaybe<OrderBy>;
  customer_refunds_aggregate?: InputMaybe<CustomerRefundsAggregateOrderBy>;
  customer_subscription?: InputMaybe<CustomerSubscriptionsOrderBy>;
  description?: InputMaybe<OrderBy>;
  error_code?: InputMaybe<OrderBy>;
  error_description?: InputMaybe<OrderBy>;
  error_reason?: InputMaybe<OrderBy>;
  error_source?: InputMaybe<OrderBy>;
  error_step?: InputMaybe<OrderBy>;
  external_order_id?: InputMaybe<OrderBy>;
  external_payment_id?: InputMaybe<OrderBy>;
  fee?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  international?: InputMaybe<OrderBy>;
  invoice_id?: InputMaybe<OrderBy>;
  method?: InputMaybe<OrderBy>;
  notes?: InputMaybe<OrderBy>;
  order_id?: InputMaybe<OrderBy>;
  payment_provider?: InputMaybe<PaymentProvidersOrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  refund_status?: InputMaybe<OrderBy>;
  status?: InputMaybe<OrderBy>;
  subscription_id?: InputMaybe<OrderBy>;
  tax?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  user_profile?: InputMaybe<UserProfilesOrderBy>;
  vpa?: InputMaybe<OrderBy>;
  wallet?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: customer_payments */
export type CustomerPaymentsPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type CustomerPaymentsPrependInput = {
  acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  notes?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "customer_payments" */
export enum CustomerPaymentsSelectColumn {
  /** column name */
  ACQUIRER_DATA = "acquirer_data",
  /** column name */
  AMOUNT = "amount",
  /** column name */
  AMOUNT_REFUNDED = "amount_refunded",
  /** column name */
  AMOUNT_TRANSFERRED = "amount_transferred",
  /** column name */
  BANK = "bank",
  /** column name */
  CAPTURED = "captured",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  CURRENCY = "currency",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  ERROR_CODE = "error_code",
  /** column name */
  ERROR_DESCRIPTION = "error_description",
  /** column name */
  ERROR_REASON = "error_reason",
  /** column name */
  ERROR_SOURCE = "error_source",
  /** column name */
  ERROR_STEP = "error_step",
  /** column name */
  EXTERNAL_ORDER_ID = "external_order_id",
  /** column name */
  EXTERNAL_PAYMENT_ID = "external_payment_id",
  /** column name */
  FEE = "fee",
  /** column name */
  ID = "id",
  /** column name */
  INTERNATIONAL = "international",
  /** column name */
  INVOICE_ID = "invoice_id",
  /** column name */
  METHOD = "method",
  /** column name */
  NOTES = "notes",
  /** column name */
  ORDER_ID = "order_id",
  /** column name */
  PAYMENT_PROVIDER_ID = "payment_provider_id",
  /** column name */
  REFUND_STATUS = "refund_status",
  /** column name */
  STATUS = "status",
  /** column name */
  SUBSCRIPTION_ID = "subscription_id",
  /** column name */
  TAX = "tax",
  /** column name */
  USER_ID = "user_id",
  /** column name */
  VPA = "vpa",
  /** column name */
  WALLET = "wallet",
}

/** select "customer_payments_aggregate_bool_exp_bool_and_arguments_columns" columns of table "customer_payments" */
export enum CustomerPaymentsSelectColumnCustomerPaymentsAggregateBoolExpBoolAndArgumentsColumns {
  /** column name */
  CAPTURED = "captured",
  /** column name */
  INTERNATIONAL = "international",
}

/** select "customer_payments_aggregate_bool_exp_bool_or_arguments_columns" columns of table "customer_payments" */
export enum CustomerPaymentsSelectColumnCustomerPaymentsAggregateBoolExpBoolOrArgumentsColumns {
  /** column name */
  CAPTURED = "captured",
  /** column name */
  INTERNATIONAL = "international",
}

/** input type for updating data in table "customer_payments" */
export type CustomerPaymentsSetInput = {
  acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  amount?: InputMaybe<Scalars["numeric"]["input"]>;
  amount_refunded?: InputMaybe<Scalars["numeric"]["input"]>;
  amount_transferred?: InputMaybe<Scalars["numeric"]["input"]>;
  bank?: InputMaybe<Scalars["String"]["input"]>;
  captured?: InputMaybe<Scalars["Boolean"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  currency?: InputMaybe<Scalars["String"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  error_code?: InputMaybe<Scalars["String"]["input"]>;
  error_description?: InputMaybe<Scalars["String"]["input"]>;
  error_reason?: InputMaybe<Scalars["String"]["input"]>;
  error_source?: InputMaybe<Scalars["String"]["input"]>;
  error_step?: InputMaybe<Scalars["String"]["input"]>;
  external_order_id?: InputMaybe<Scalars["String"]["input"]>;
  external_payment_id?: InputMaybe<Scalars["String"]["input"]>;
  fee?: InputMaybe<Scalars["numeric"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  international?: InputMaybe<Scalars["Boolean"]["input"]>;
  invoice_id?: InputMaybe<Scalars["String"]["input"]>;
  method?: InputMaybe<Scalars["String"]["input"]>;
  notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  order_id?: InputMaybe<Scalars["String"]["input"]>;
  payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  refund_status?: InputMaybe<Scalars["String"]["input"]>;
  status?: InputMaybe<Scalars["String"]["input"]>;
  subscription_id?: InputMaybe<Scalars["Int"]["input"]>;
  tax?: InputMaybe<Scalars["numeric"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  vpa?: InputMaybe<Scalars["String"]["input"]>;
  wallet?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type CustomerPaymentsStddevFields = {
  __typename?: "customer_payments_stddev_fields";
  amount?: Maybe<Scalars["Float"]["output"]>;
  amount_refunded?: Maybe<Scalars["Float"]["output"]>;
  amount_transferred?: Maybe<Scalars["Float"]["output"]>;
  fee?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  subscription_id?: Maybe<Scalars["Float"]["output"]>;
  tax?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "customer_payments" */
export type CustomerPaymentsStddevOrderBy = {
  amount?: InputMaybe<OrderBy>;
  amount_refunded?: InputMaybe<OrderBy>;
  amount_transferred?: InputMaybe<OrderBy>;
  fee?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  subscription_id?: InputMaybe<OrderBy>;
  tax?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type CustomerPaymentsStddevPopFields = {
  __typename?: "customer_payments_stddev_pop_fields";
  amount?: Maybe<Scalars["Float"]["output"]>;
  amount_refunded?: Maybe<Scalars["Float"]["output"]>;
  amount_transferred?: Maybe<Scalars["Float"]["output"]>;
  fee?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  subscription_id?: Maybe<Scalars["Float"]["output"]>;
  tax?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "customer_payments" */
export type CustomerPaymentsStddevPopOrderBy = {
  amount?: InputMaybe<OrderBy>;
  amount_refunded?: InputMaybe<OrderBy>;
  amount_transferred?: InputMaybe<OrderBy>;
  fee?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  subscription_id?: InputMaybe<OrderBy>;
  tax?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type CustomerPaymentsStddevSampFields = {
  __typename?: "customer_payments_stddev_samp_fields";
  amount?: Maybe<Scalars["Float"]["output"]>;
  amount_refunded?: Maybe<Scalars["Float"]["output"]>;
  amount_transferred?: Maybe<Scalars["Float"]["output"]>;
  fee?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  subscription_id?: Maybe<Scalars["Float"]["output"]>;
  tax?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "customer_payments" */
export type CustomerPaymentsStddevSampOrderBy = {
  amount?: InputMaybe<OrderBy>;
  amount_refunded?: InputMaybe<OrderBy>;
  amount_transferred?: InputMaybe<OrderBy>;
  fee?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  subscription_id?: InputMaybe<OrderBy>;
  tax?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "customer_payments" */
export type CustomerPaymentsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CustomerPaymentsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CustomerPaymentsStreamCursorValueInput = {
  acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  amount?: InputMaybe<Scalars["numeric"]["input"]>;
  amount_refunded?: InputMaybe<Scalars["numeric"]["input"]>;
  amount_transferred?: InputMaybe<Scalars["numeric"]["input"]>;
  bank?: InputMaybe<Scalars["String"]["input"]>;
  captured?: InputMaybe<Scalars["Boolean"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  currency?: InputMaybe<Scalars["String"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  error_code?: InputMaybe<Scalars["String"]["input"]>;
  error_description?: InputMaybe<Scalars["String"]["input"]>;
  error_reason?: InputMaybe<Scalars["String"]["input"]>;
  error_source?: InputMaybe<Scalars["String"]["input"]>;
  error_step?: InputMaybe<Scalars["String"]["input"]>;
  external_order_id?: InputMaybe<Scalars["String"]["input"]>;
  external_payment_id?: InputMaybe<Scalars["String"]["input"]>;
  fee?: InputMaybe<Scalars["numeric"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  international?: InputMaybe<Scalars["Boolean"]["input"]>;
  invoice_id?: InputMaybe<Scalars["String"]["input"]>;
  method?: InputMaybe<Scalars["String"]["input"]>;
  notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  order_id?: InputMaybe<Scalars["String"]["input"]>;
  payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  refund_status?: InputMaybe<Scalars["String"]["input"]>;
  status?: InputMaybe<Scalars["String"]["input"]>;
  subscription_id?: InputMaybe<Scalars["Int"]["input"]>;
  tax?: InputMaybe<Scalars["numeric"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  vpa?: InputMaybe<Scalars["String"]["input"]>;
  wallet?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type CustomerPaymentsSumFields = {
  __typename?: "customer_payments_sum_fields";
  amount?: Maybe<Scalars["numeric"]["output"]>;
  amount_refunded?: Maybe<Scalars["numeric"]["output"]>;
  amount_transferred?: Maybe<Scalars["numeric"]["output"]>;
  fee?: Maybe<Scalars["numeric"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Int"]["output"]>;
  subscription_id?: Maybe<Scalars["Int"]["output"]>;
  tax?: Maybe<Scalars["numeric"]["output"]>;
};

/** order by sum() on columns of table "customer_payments" */
export type CustomerPaymentsSumOrderBy = {
  amount?: InputMaybe<OrderBy>;
  amount_refunded?: InputMaybe<OrderBy>;
  amount_transferred?: InputMaybe<OrderBy>;
  fee?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  subscription_id?: InputMaybe<OrderBy>;
  tax?: InputMaybe<OrderBy>;
};

/** update columns of table "customer_payments" */
export enum CustomerPaymentsUpdateColumn {
  /** column name */
  ACQUIRER_DATA = "acquirer_data",
  /** column name */
  AMOUNT = "amount",
  /** column name */
  AMOUNT_REFUNDED = "amount_refunded",
  /** column name */
  AMOUNT_TRANSFERRED = "amount_transferred",
  /** column name */
  BANK = "bank",
  /** column name */
  CAPTURED = "captured",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  CURRENCY = "currency",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  ERROR_CODE = "error_code",
  /** column name */
  ERROR_DESCRIPTION = "error_description",
  /** column name */
  ERROR_REASON = "error_reason",
  /** column name */
  ERROR_SOURCE = "error_source",
  /** column name */
  ERROR_STEP = "error_step",
  /** column name */
  EXTERNAL_ORDER_ID = "external_order_id",
  /** column name */
  EXTERNAL_PAYMENT_ID = "external_payment_id",
  /** column name */
  FEE = "fee",
  /** column name */
  ID = "id",
  /** column name */
  INTERNATIONAL = "international",
  /** column name */
  INVOICE_ID = "invoice_id",
  /** column name */
  METHOD = "method",
  /** column name */
  NOTES = "notes",
  /** column name */
  ORDER_ID = "order_id",
  /** column name */
  PAYMENT_PROVIDER_ID = "payment_provider_id",
  /** column name */
  REFUND_STATUS = "refund_status",
  /** column name */
  STATUS = "status",
  /** column name */
  SUBSCRIPTION_ID = "subscription_id",
  /** column name */
  TAX = "tax",
  /** column name */
  USER_ID = "user_id",
  /** column name */
  VPA = "vpa",
  /** column name */
  WALLET = "wallet",
}

export type CustomerPaymentsUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<CustomerPaymentsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<CustomerPaymentsDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<CustomerPaymentsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<CustomerPaymentsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<CustomerPaymentsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<CustomerPaymentsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CustomerPaymentsSetInput>;
  /** filter the rows which have to be updated */
  where: CustomerPaymentsBoolExp;
};

/** aggregate var_pop on columns */
export type CustomerPaymentsVarPopFields = {
  __typename?: "customer_payments_var_pop_fields";
  amount?: Maybe<Scalars["Float"]["output"]>;
  amount_refunded?: Maybe<Scalars["Float"]["output"]>;
  amount_transferred?: Maybe<Scalars["Float"]["output"]>;
  fee?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  subscription_id?: Maybe<Scalars["Float"]["output"]>;
  tax?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "customer_payments" */
export type CustomerPaymentsVarPopOrderBy = {
  amount?: InputMaybe<OrderBy>;
  amount_refunded?: InputMaybe<OrderBy>;
  amount_transferred?: InputMaybe<OrderBy>;
  fee?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  subscription_id?: InputMaybe<OrderBy>;
  tax?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type CustomerPaymentsVarSampFields = {
  __typename?: "customer_payments_var_samp_fields";
  amount?: Maybe<Scalars["Float"]["output"]>;
  amount_refunded?: Maybe<Scalars["Float"]["output"]>;
  amount_transferred?: Maybe<Scalars["Float"]["output"]>;
  fee?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  subscription_id?: Maybe<Scalars["Float"]["output"]>;
  tax?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "customer_payments" */
export type CustomerPaymentsVarSampOrderBy = {
  amount?: InputMaybe<OrderBy>;
  amount_refunded?: InputMaybe<OrderBy>;
  amount_transferred?: InputMaybe<OrderBy>;
  fee?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  subscription_id?: InputMaybe<OrderBy>;
  tax?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type CustomerPaymentsVarianceFields = {
  __typename?: "customer_payments_variance_fields";
  amount?: Maybe<Scalars["Float"]["output"]>;
  amount_refunded?: Maybe<Scalars["Float"]["output"]>;
  amount_transferred?: Maybe<Scalars["Float"]["output"]>;
  fee?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  subscription_id?: Maybe<Scalars["Float"]["output"]>;
  tax?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "customer_payments" */
export type CustomerPaymentsVarianceOrderBy = {
  amount?: InputMaybe<OrderBy>;
  amount_refunded?: InputMaybe<OrderBy>;
  amount_transferred?: InputMaybe<OrderBy>;
  fee?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  subscription_id?: InputMaybe<OrderBy>;
  tax?: InputMaybe<OrderBy>;
};

/** columns and relationships of "customer_processed_webhooks" */
export type CustomerProcessedWebhooks = {
  __typename?: "customer_processed_webhooks";
  event_id: Scalars["String"]["output"];
  event_type: Scalars["String"]["output"];
  id: Scalars["Int"]["output"];
  processed_at: Scalars["timestamptz"]["output"];
};

/** aggregated selection of "customer_processed_webhooks" */
export type CustomerProcessedWebhooksAggregate = {
  __typename?: "customer_processed_webhooks_aggregate";
  aggregate?: Maybe<CustomerProcessedWebhooksAggregateFields>;
  nodes: Array<CustomerProcessedWebhooks>;
};

/** aggregate fields of "customer_processed_webhooks" */
export type CustomerProcessedWebhooksAggregateFields = {
  __typename?: "customer_processed_webhooks_aggregate_fields";
  avg?: Maybe<CustomerProcessedWebhooksAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<CustomerProcessedWebhooksMaxFields>;
  min?: Maybe<CustomerProcessedWebhooksMinFields>;
  stddev?: Maybe<CustomerProcessedWebhooksStddevFields>;
  stddev_pop?: Maybe<CustomerProcessedWebhooksStddevPopFields>;
  stddev_samp?: Maybe<CustomerProcessedWebhooksStddevSampFields>;
  sum?: Maybe<CustomerProcessedWebhooksSumFields>;
  var_pop?: Maybe<CustomerProcessedWebhooksVarPopFields>;
  var_samp?: Maybe<CustomerProcessedWebhooksVarSampFields>;
  variance?: Maybe<CustomerProcessedWebhooksVarianceFields>;
};

/** aggregate fields of "customer_processed_webhooks" */
export type CustomerProcessedWebhooksAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CustomerProcessedWebhooksSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type CustomerProcessedWebhooksAvgFields = {
  __typename?: "customer_processed_webhooks_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "customer_processed_webhooks". All fields are combined with a logical 'AND'. */
export type CustomerProcessedWebhooksBoolExp = {
  _and?: InputMaybe<Array<CustomerProcessedWebhooksBoolExp>>;
  _not?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
  _or?: InputMaybe<Array<CustomerProcessedWebhooksBoolExp>>;
  event_id?: InputMaybe<StringComparisonExp>;
  event_type?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  processed_at?: InputMaybe<TimestamptzComparisonExp>;
};

/** unique or primary key constraints on table "customer_processed_webhooks" */
export enum CustomerProcessedWebhooksConstraint {
  /** unique or primary key constraint on columns "event_id" */
  CUSTOMERS_PROCESSED_WEBHOOKS_EVENT_ID_KEY = "customers_processed_webhooks_event_id_key",
  /** unique or primary key constraint on columns "id" */
  CUSTOMERS_PROCESSED_WEBHOOKS_PKEY = "customers_processed_webhooks_pkey",
}

/** input type for incrementing numeric columns in table "customer_processed_webhooks" */
export type CustomerProcessedWebhooksIncInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "customer_processed_webhooks" */
export type CustomerProcessedWebhooksInsertInput = {
  event_id?: InputMaybe<Scalars["String"]["input"]>;
  event_type?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  processed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate max on columns */
export type CustomerProcessedWebhooksMaxFields = {
  __typename?: "customer_processed_webhooks_max_fields";
  event_id?: Maybe<Scalars["String"]["output"]>;
  event_type?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  processed_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregate min on columns */
export type CustomerProcessedWebhooksMinFields = {
  __typename?: "customer_processed_webhooks_min_fields";
  event_id?: Maybe<Scalars["String"]["output"]>;
  event_type?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  processed_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** response of any mutation on the table "customer_processed_webhooks" */
export type CustomerProcessedWebhooksMutationResponse = {
  __typename?: "customer_processed_webhooks_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<CustomerProcessedWebhooks>;
};

/** on_conflict condition type for table "customer_processed_webhooks" */
export type CustomerProcessedWebhooksOnConflict = {
  constraint: CustomerProcessedWebhooksConstraint;
  update_columns?: Array<CustomerProcessedWebhooksUpdateColumn>;
  where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
};

/** Ordering options when selecting data from "customer_processed_webhooks". */
export type CustomerProcessedWebhooksOrderBy = {
  event_id?: InputMaybe<OrderBy>;
  event_type?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  processed_at?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: customer_processed_webhooks */
export type CustomerProcessedWebhooksPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "customer_processed_webhooks" */
export enum CustomerProcessedWebhooksSelectColumn {
  /** column name */
  EVENT_ID = "event_id",
  /** column name */
  EVENT_TYPE = "event_type",
  /** column name */
  ID = "id",
  /** column name */
  PROCESSED_AT = "processed_at",
}

/** input type for updating data in table "customer_processed_webhooks" */
export type CustomerProcessedWebhooksSetInput = {
  event_id?: InputMaybe<Scalars["String"]["input"]>;
  event_type?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  processed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate stddev on columns */
export type CustomerProcessedWebhooksStddevFields = {
  __typename?: "customer_processed_webhooks_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type CustomerProcessedWebhooksStddevPopFields = {
  __typename?: "customer_processed_webhooks_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type CustomerProcessedWebhooksStddevSampFields = {
  __typename?: "customer_processed_webhooks_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "customer_processed_webhooks" */
export type CustomerProcessedWebhooksStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CustomerProcessedWebhooksStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CustomerProcessedWebhooksStreamCursorValueInput = {
  event_id?: InputMaybe<Scalars["String"]["input"]>;
  event_type?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  processed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate sum on columns */
export type CustomerProcessedWebhooksSumFields = {
  __typename?: "customer_processed_webhooks_sum_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "customer_processed_webhooks" */
export enum CustomerProcessedWebhooksUpdateColumn {
  /** column name */
  EVENT_ID = "event_id",
  /** column name */
  EVENT_TYPE = "event_type",
  /** column name */
  ID = "id",
  /** column name */
  PROCESSED_AT = "processed_at",
}

export type CustomerProcessedWebhooksUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<CustomerProcessedWebhooksIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CustomerProcessedWebhooksSetInput>;
  /** filter the rows which have to be updated */
  where: CustomerProcessedWebhooksBoolExp;
};

/** aggregate var_pop on columns */
export type CustomerProcessedWebhooksVarPopFields = {
  __typename?: "customer_processed_webhooks_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type CustomerProcessedWebhooksVarSampFields = {
  __typename?: "customer_processed_webhooks_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type CustomerProcessedWebhooksVarianceFields = {
  __typename?: "customer_processed_webhooks_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "customer_refunds" */
export type CustomerRefunds = {
  __typename?: "customer_refunds";
  acquirer_data?: Maybe<Scalars["jsonb"]["output"]>;
  amount: Scalars["numeric"]["output"];
  batch_id?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  currency?: Maybe<Scalars["String"]["output"]>;
  /** An object relationship */
  customer_payment: CustomerPayments;
  external_refund_id: Scalars["String"]["output"];
  id: Scalars["Int"]["output"];
  notes?: Maybe<Scalars["jsonb"]["output"]>;
  payment_id: Scalars["Int"]["output"];
  receipt?: Maybe<Scalars["String"]["output"]>;
  speed_processed?: Maybe<Scalars["String"]["output"]>;
  speed_requested?: Maybe<Scalars["String"]["output"]>;
  status: Scalars["String"]["output"];
};

/** columns and relationships of "customer_refunds" */
export type CustomerRefundsAcquirerDataArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "customer_refunds" */
export type CustomerRefundsNotesArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "customer_refunds" */
export type CustomerRefundsAggregate = {
  __typename?: "customer_refunds_aggregate";
  aggregate?: Maybe<CustomerRefundsAggregateFields>;
  nodes: Array<CustomerRefunds>;
};

export type CustomerRefundsAggregateBoolExp = {
  count?: InputMaybe<CustomerRefundsAggregateBoolExpCount>;
};

export type CustomerRefundsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<CustomerRefundsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CustomerRefundsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "customer_refunds" */
export type CustomerRefundsAggregateFields = {
  __typename?: "customer_refunds_aggregate_fields";
  avg?: Maybe<CustomerRefundsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<CustomerRefundsMaxFields>;
  min?: Maybe<CustomerRefundsMinFields>;
  stddev?: Maybe<CustomerRefundsStddevFields>;
  stddev_pop?: Maybe<CustomerRefundsStddevPopFields>;
  stddev_samp?: Maybe<CustomerRefundsStddevSampFields>;
  sum?: Maybe<CustomerRefundsSumFields>;
  var_pop?: Maybe<CustomerRefundsVarPopFields>;
  var_samp?: Maybe<CustomerRefundsVarSampFields>;
  variance?: Maybe<CustomerRefundsVarianceFields>;
};

/** aggregate fields of "customer_refunds" */
export type CustomerRefundsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CustomerRefundsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "customer_refunds" */
export type CustomerRefundsAggregateOrderBy = {
  avg?: InputMaybe<CustomerRefundsAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<CustomerRefundsMaxOrderBy>;
  min?: InputMaybe<CustomerRefundsMinOrderBy>;
  stddev?: InputMaybe<CustomerRefundsStddevOrderBy>;
  stddev_pop?: InputMaybe<CustomerRefundsStddevPopOrderBy>;
  stddev_samp?: InputMaybe<CustomerRefundsStddevSampOrderBy>;
  sum?: InputMaybe<CustomerRefundsSumOrderBy>;
  var_pop?: InputMaybe<CustomerRefundsVarPopOrderBy>;
  var_samp?: InputMaybe<CustomerRefundsVarSampOrderBy>;
  variance?: InputMaybe<CustomerRefundsVarianceOrderBy>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type CustomerRefundsAppendInput = {
  acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  notes?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** input type for inserting array relation for remote table "customer_refunds" */
export type CustomerRefundsArrRelInsertInput = {
  data: Array<CustomerRefundsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<CustomerRefundsOnConflict>;
};

/** aggregate avg on columns */
export type CustomerRefundsAvgFields = {
  __typename?: "customer_refunds_avg_fields";
  amount?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  payment_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "customer_refunds" */
export type CustomerRefundsAvgOrderBy = {
  amount?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "customer_refunds". All fields are combined with a logical 'AND'. */
export type CustomerRefundsBoolExp = {
  _and?: InputMaybe<Array<CustomerRefundsBoolExp>>;
  _not?: InputMaybe<CustomerRefundsBoolExp>;
  _or?: InputMaybe<Array<CustomerRefundsBoolExp>>;
  acquirer_data?: InputMaybe<JsonbComparisonExp>;
  amount?: InputMaybe<NumericComparisonExp>;
  batch_id?: InputMaybe<StringComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  currency?: InputMaybe<StringComparisonExp>;
  customer_payment?: InputMaybe<CustomerPaymentsBoolExp>;
  external_refund_id?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  notes?: InputMaybe<JsonbComparisonExp>;
  payment_id?: InputMaybe<IntComparisonExp>;
  receipt?: InputMaybe<StringComparisonExp>;
  speed_processed?: InputMaybe<StringComparisonExp>;
  speed_requested?: InputMaybe<StringComparisonExp>;
  status?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "customer_refunds" */
export enum CustomerRefundsConstraint {
  /** unique or primary key constraint on columns "id" */
  CUSTOMER_REFUNDS_PKEY = "customer_refunds_pkey",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type CustomerRefundsDeleteAtPathInput = {
  acquirer_data?: InputMaybe<Array<Scalars["String"]["input"]>>;
  notes?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type CustomerRefundsDeleteElemInput = {
  acquirer_data?: InputMaybe<Scalars["Int"]["input"]>;
  notes?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type CustomerRefundsDeleteKeyInput = {
  acquirer_data?: InputMaybe<Scalars["String"]["input"]>;
  notes?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for incrementing numeric columns in table "customer_refunds" */
export type CustomerRefundsIncInput = {
  amount?: InputMaybe<Scalars["numeric"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  payment_id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "customer_refunds" */
export type CustomerRefundsInsertInput = {
  acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  amount?: InputMaybe<Scalars["numeric"]["input"]>;
  batch_id?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  currency?: InputMaybe<Scalars["String"]["input"]>;
  customer_payment?: InputMaybe<CustomerPaymentsObjRelInsertInput>;
  external_refund_id?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  payment_id?: InputMaybe<Scalars["Int"]["input"]>;
  receipt?: InputMaybe<Scalars["String"]["input"]>;
  speed_processed?: InputMaybe<Scalars["String"]["input"]>;
  speed_requested?: InputMaybe<Scalars["String"]["input"]>;
  status?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type CustomerRefundsMaxFields = {
  __typename?: "customer_refunds_max_fields";
  amount?: Maybe<Scalars["numeric"]["output"]>;
  batch_id?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  currency?: Maybe<Scalars["String"]["output"]>;
  external_refund_id?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  payment_id?: Maybe<Scalars["Int"]["output"]>;
  receipt?: Maybe<Scalars["String"]["output"]>;
  speed_processed?: Maybe<Scalars["String"]["output"]>;
  speed_requested?: Maybe<Scalars["String"]["output"]>;
  status?: Maybe<Scalars["String"]["output"]>;
};

/** order by max() on columns of table "customer_refunds" */
export type CustomerRefundsMaxOrderBy = {
  amount?: InputMaybe<OrderBy>;
  batch_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  currency?: InputMaybe<OrderBy>;
  external_refund_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_id?: InputMaybe<OrderBy>;
  receipt?: InputMaybe<OrderBy>;
  speed_processed?: InputMaybe<OrderBy>;
  speed_requested?: InputMaybe<OrderBy>;
  status?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type CustomerRefundsMinFields = {
  __typename?: "customer_refunds_min_fields";
  amount?: Maybe<Scalars["numeric"]["output"]>;
  batch_id?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  currency?: Maybe<Scalars["String"]["output"]>;
  external_refund_id?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  payment_id?: Maybe<Scalars["Int"]["output"]>;
  receipt?: Maybe<Scalars["String"]["output"]>;
  speed_processed?: Maybe<Scalars["String"]["output"]>;
  speed_requested?: Maybe<Scalars["String"]["output"]>;
  status?: Maybe<Scalars["String"]["output"]>;
};

/** order by min() on columns of table "customer_refunds" */
export type CustomerRefundsMinOrderBy = {
  amount?: InputMaybe<OrderBy>;
  batch_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  currency?: InputMaybe<OrderBy>;
  external_refund_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_id?: InputMaybe<OrderBy>;
  receipt?: InputMaybe<OrderBy>;
  speed_processed?: InputMaybe<OrderBy>;
  speed_requested?: InputMaybe<OrderBy>;
  status?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "customer_refunds" */
export type CustomerRefundsMutationResponse = {
  __typename?: "customer_refunds_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<CustomerRefunds>;
};

/** on_conflict condition type for table "customer_refunds" */
export type CustomerRefundsOnConflict = {
  constraint: CustomerRefundsConstraint;
  update_columns?: Array<CustomerRefundsUpdateColumn>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
};

/** Ordering options when selecting data from "customer_refunds". */
export type CustomerRefundsOrderBy = {
  acquirer_data?: InputMaybe<OrderBy>;
  amount?: InputMaybe<OrderBy>;
  batch_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  currency?: InputMaybe<OrderBy>;
  customer_payment?: InputMaybe<CustomerPaymentsOrderBy>;
  external_refund_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  notes?: InputMaybe<OrderBy>;
  payment_id?: InputMaybe<OrderBy>;
  receipt?: InputMaybe<OrderBy>;
  speed_processed?: InputMaybe<OrderBy>;
  speed_requested?: InputMaybe<OrderBy>;
  status?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: customer_refunds */
export type CustomerRefundsPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type CustomerRefundsPrependInput = {
  acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  notes?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "customer_refunds" */
export enum CustomerRefundsSelectColumn {
  /** column name */
  ACQUIRER_DATA = "acquirer_data",
  /** column name */
  AMOUNT = "amount",
  /** column name */
  BATCH_ID = "batch_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  CURRENCY = "currency",
  /** column name */
  EXTERNAL_REFUND_ID = "external_refund_id",
  /** column name */
  ID = "id",
  /** column name */
  NOTES = "notes",
  /** column name */
  PAYMENT_ID = "payment_id",
  /** column name */
  RECEIPT = "receipt",
  /** column name */
  SPEED_PROCESSED = "speed_processed",
  /** column name */
  SPEED_REQUESTED = "speed_requested",
  /** column name */
  STATUS = "status",
}

/** input type for updating data in table "customer_refunds" */
export type CustomerRefundsSetInput = {
  acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  amount?: InputMaybe<Scalars["numeric"]["input"]>;
  batch_id?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  currency?: InputMaybe<Scalars["String"]["input"]>;
  external_refund_id?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  payment_id?: InputMaybe<Scalars["Int"]["input"]>;
  receipt?: InputMaybe<Scalars["String"]["input"]>;
  speed_processed?: InputMaybe<Scalars["String"]["input"]>;
  speed_requested?: InputMaybe<Scalars["String"]["input"]>;
  status?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type CustomerRefundsStddevFields = {
  __typename?: "customer_refunds_stddev_fields";
  amount?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  payment_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "customer_refunds" */
export type CustomerRefundsStddevOrderBy = {
  amount?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type CustomerRefundsStddevPopFields = {
  __typename?: "customer_refunds_stddev_pop_fields";
  amount?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  payment_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "customer_refunds" */
export type CustomerRefundsStddevPopOrderBy = {
  amount?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type CustomerRefundsStddevSampFields = {
  __typename?: "customer_refunds_stddev_samp_fields";
  amount?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  payment_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "customer_refunds" */
export type CustomerRefundsStddevSampOrderBy = {
  amount?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "customer_refunds" */
export type CustomerRefundsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CustomerRefundsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CustomerRefundsStreamCursorValueInput = {
  acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  amount?: InputMaybe<Scalars["numeric"]["input"]>;
  batch_id?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  currency?: InputMaybe<Scalars["String"]["input"]>;
  external_refund_id?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  payment_id?: InputMaybe<Scalars["Int"]["input"]>;
  receipt?: InputMaybe<Scalars["String"]["input"]>;
  speed_processed?: InputMaybe<Scalars["String"]["input"]>;
  speed_requested?: InputMaybe<Scalars["String"]["input"]>;
  status?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type CustomerRefundsSumFields = {
  __typename?: "customer_refunds_sum_fields";
  amount?: Maybe<Scalars["numeric"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  payment_id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "customer_refunds" */
export type CustomerRefundsSumOrderBy = {
  amount?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_id?: InputMaybe<OrderBy>;
};

/** update columns of table "customer_refunds" */
export enum CustomerRefundsUpdateColumn {
  /** column name */
  ACQUIRER_DATA = "acquirer_data",
  /** column name */
  AMOUNT = "amount",
  /** column name */
  BATCH_ID = "batch_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  CURRENCY = "currency",
  /** column name */
  EXTERNAL_REFUND_ID = "external_refund_id",
  /** column name */
  ID = "id",
  /** column name */
  NOTES = "notes",
  /** column name */
  PAYMENT_ID = "payment_id",
  /** column name */
  RECEIPT = "receipt",
  /** column name */
  SPEED_PROCESSED = "speed_processed",
  /** column name */
  SPEED_REQUESTED = "speed_requested",
  /** column name */
  STATUS = "status",
}

export type CustomerRefundsUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<CustomerRefundsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<CustomerRefundsDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<CustomerRefundsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<CustomerRefundsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<CustomerRefundsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<CustomerRefundsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CustomerRefundsSetInput>;
  /** filter the rows which have to be updated */
  where: CustomerRefundsBoolExp;
};

/** aggregate var_pop on columns */
export type CustomerRefundsVarPopFields = {
  __typename?: "customer_refunds_var_pop_fields";
  amount?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  payment_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "customer_refunds" */
export type CustomerRefundsVarPopOrderBy = {
  amount?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type CustomerRefundsVarSampFields = {
  __typename?: "customer_refunds_var_samp_fields";
  amount?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  payment_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "customer_refunds" */
export type CustomerRefundsVarSampOrderBy = {
  amount?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type CustomerRefundsVarianceFields = {
  __typename?: "customer_refunds_variance_fields";
  amount?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  payment_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "customer_refunds" */
export type CustomerRefundsVarianceOrderBy = {
  amount?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  payment_id?: InputMaybe<OrderBy>;
};

/** columns and relationships of "customer_subscription_plans" */
export type CustomerSubscriptionPlans = {
  __typename?: "customer_subscription_plans";
  annual_amount: Scalars["numeric"]["output"];
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  currency: Scalars["String"]["output"];
  /** An array relationship */
  customer_subscriptions: Array<CustomerSubscriptions>;
  /** An aggregate relationship */
  customer_subscriptions_aggregate: CustomerSubscriptionsAggregate;
  description?: Maybe<Scalars["String"]["output"]>;
  external_plan_id?: Maybe<Scalars["String"]["output"]>;
  features?: Maybe<Scalars["jsonb"]["output"]>;
  id: Scalars["Int"]["output"];
  interval: Scalars["Int"]["output"];
  interval_type: Scalars["String"]["output"];
  is_active?: Maybe<Scalars["Boolean"]["output"]>;
  monthly_amount: Scalars["numeric"]["output"];
  name: Scalars["String"]["output"];
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** columns and relationships of "customer_subscription_plans" */
export type CustomerSubscriptionPlansCustomerSubscriptionsArgs = {
  distinct_on?: InputMaybe<Array<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

/** columns and relationships of "customer_subscription_plans" */
export type CustomerSubscriptionPlansCustomerSubscriptionsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

/** columns and relationships of "customer_subscription_plans" */
export type CustomerSubscriptionPlansFeaturesArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "customer_subscription_plans" */
export type CustomerSubscriptionPlansAggregate = {
  __typename?: "customer_subscription_plans_aggregate";
  aggregate?: Maybe<CustomerSubscriptionPlansAggregateFields>;
  nodes: Array<CustomerSubscriptionPlans>;
};

/** aggregate fields of "customer_subscription_plans" */
export type CustomerSubscriptionPlansAggregateFields = {
  __typename?: "customer_subscription_plans_aggregate_fields";
  avg?: Maybe<CustomerSubscriptionPlansAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<CustomerSubscriptionPlansMaxFields>;
  min?: Maybe<CustomerSubscriptionPlansMinFields>;
  stddev?: Maybe<CustomerSubscriptionPlansStddevFields>;
  stddev_pop?: Maybe<CustomerSubscriptionPlansStddevPopFields>;
  stddev_samp?: Maybe<CustomerSubscriptionPlansStddevSampFields>;
  sum?: Maybe<CustomerSubscriptionPlansSumFields>;
  var_pop?: Maybe<CustomerSubscriptionPlansVarPopFields>;
  var_samp?: Maybe<CustomerSubscriptionPlansVarSampFields>;
  variance?: Maybe<CustomerSubscriptionPlansVarianceFields>;
};

/** aggregate fields of "customer_subscription_plans" */
export type CustomerSubscriptionPlansAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CustomerSubscriptionPlansSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type CustomerSubscriptionPlansAppendInput = {
  features?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** aggregate avg on columns */
export type CustomerSubscriptionPlansAvgFields = {
  __typename?: "customer_subscription_plans_avg_fields";
  annual_amount?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  interval?: Maybe<Scalars["Float"]["output"]>;
  monthly_amount?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "customer_subscription_plans". All fields are combined with a logical 'AND'. */
export type CustomerSubscriptionPlansBoolExp = {
  _and?: InputMaybe<Array<CustomerSubscriptionPlansBoolExp>>;
  _not?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
  _or?: InputMaybe<Array<CustomerSubscriptionPlansBoolExp>>;
  annual_amount?: InputMaybe<NumericComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  currency?: InputMaybe<StringComparisonExp>;
  customer_subscriptions?: InputMaybe<CustomerSubscriptionsBoolExp>;
  customer_subscriptions_aggregate?: InputMaybe<CustomerSubscriptionsAggregateBoolExp>;
  description?: InputMaybe<StringComparisonExp>;
  external_plan_id?: InputMaybe<StringComparisonExp>;
  features?: InputMaybe<JsonbComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  interval?: InputMaybe<IntComparisonExp>;
  interval_type?: InputMaybe<StringComparisonExp>;
  is_active?: InputMaybe<BooleanComparisonExp>;
  monthly_amount?: InputMaybe<NumericComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
};

/** unique or primary key constraints on table "customer_subscription_plans" */
export enum CustomerSubscriptionPlansConstraint {
  /** unique or primary key constraint on columns "external_plan_id" */
  CUSTOMER_SUBSCRIPTION_PLANS_EXTERNAL_PLAN_ID_KEY = "customer_subscription_plans_external_plan_id_key",
  /** unique or primary key constraint on columns "id" */
  CUSTOMER_SUBSCRIPTION_PLANS_PKEY = "customer_subscription_plans_pkey",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type CustomerSubscriptionPlansDeleteAtPathInput = {
  features?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type CustomerSubscriptionPlansDeleteElemInput = {
  features?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type CustomerSubscriptionPlansDeleteKeyInput = {
  features?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for incrementing numeric columns in table "customer_subscription_plans" */
export type CustomerSubscriptionPlansIncInput = {
  annual_amount?: InputMaybe<Scalars["numeric"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  interval?: InputMaybe<Scalars["Int"]["input"]>;
  monthly_amount?: InputMaybe<Scalars["numeric"]["input"]>;
};

/** input type for inserting data into table "customer_subscription_plans" */
export type CustomerSubscriptionPlansInsertInput = {
  annual_amount?: InputMaybe<Scalars["numeric"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  currency?: InputMaybe<Scalars["String"]["input"]>;
  customer_subscriptions?: InputMaybe<CustomerSubscriptionsArrRelInsertInput>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  external_plan_id?: InputMaybe<Scalars["String"]["input"]>;
  features?: InputMaybe<Scalars["jsonb"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  interval?: InputMaybe<Scalars["Int"]["input"]>;
  interval_type?: InputMaybe<Scalars["String"]["input"]>;
  is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  monthly_amount?: InputMaybe<Scalars["numeric"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate max on columns */
export type CustomerSubscriptionPlansMaxFields = {
  __typename?: "customer_subscription_plans_max_fields";
  annual_amount?: Maybe<Scalars["numeric"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  currency?: Maybe<Scalars["String"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  external_plan_id?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  interval?: Maybe<Scalars["Int"]["output"]>;
  interval_type?: Maybe<Scalars["String"]["output"]>;
  monthly_amount?: Maybe<Scalars["numeric"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregate min on columns */
export type CustomerSubscriptionPlansMinFields = {
  __typename?: "customer_subscription_plans_min_fields";
  annual_amount?: Maybe<Scalars["numeric"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  currency?: Maybe<Scalars["String"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  external_plan_id?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  interval?: Maybe<Scalars["Int"]["output"]>;
  interval_type?: Maybe<Scalars["String"]["output"]>;
  monthly_amount?: Maybe<Scalars["numeric"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** response of any mutation on the table "customer_subscription_plans" */
export type CustomerSubscriptionPlansMutationResponse = {
  __typename?: "customer_subscription_plans_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<CustomerSubscriptionPlans>;
};

/** input type for inserting object relation for remote table "customer_subscription_plans" */
export type CustomerSubscriptionPlansObjRelInsertInput = {
  data: CustomerSubscriptionPlansInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<CustomerSubscriptionPlansOnConflict>;
};

/** on_conflict condition type for table "customer_subscription_plans" */
export type CustomerSubscriptionPlansOnConflict = {
  constraint: CustomerSubscriptionPlansConstraint;
  update_columns?: Array<CustomerSubscriptionPlansUpdateColumn>;
  where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
};

/** Ordering options when selecting data from "customer_subscription_plans". */
export type CustomerSubscriptionPlansOrderBy = {
  annual_amount?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  currency?: InputMaybe<OrderBy>;
  customer_subscriptions_aggregate?: InputMaybe<CustomerSubscriptionsAggregateOrderBy>;
  description?: InputMaybe<OrderBy>;
  external_plan_id?: InputMaybe<OrderBy>;
  features?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  interval?: InputMaybe<OrderBy>;
  interval_type?: InputMaybe<OrderBy>;
  is_active?: InputMaybe<OrderBy>;
  monthly_amount?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: customer_subscription_plans */
export type CustomerSubscriptionPlansPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type CustomerSubscriptionPlansPrependInput = {
  features?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "customer_subscription_plans" */
export enum CustomerSubscriptionPlansSelectColumn {
  /** column name */
  ANNUAL_AMOUNT = "annual_amount",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  CURRENCY = "currency",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  EXTERNAL_PLAN_ID = "external_plan_id",
  /** column name */
  FEATURES = "features",
  /** column name */
  ID = "id",
  /** column name */
  INTERVAL = "interval",
  /** column name */
  INTERVAL_TYPE = "interval_type",
  /** column name */
  IS_ACTIVE = "is_active",
  /** column name */
  MONTHLY_AMOUNT = "monthly_amount",
  /** column name */
  NAME = "name",
  /** column name */
  UPDATED_AT = "updated_at",
}

/** input type for updating data in table "customer_subscription_plans" */
export type CustomerSubscriptionPlansSetInput = {
  annual_amount?: InputMaybe<Scalars["numeric"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  currency?: InputMaybe<Scalars["String"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  external_plan_id?: InputMaybe<Scalars["String"]["input"]>;
  features?: InputMaybe<Scalars["jsonb"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  interval?: InputMaybe<Scalars["Int"]["input"]>;
  interval_type?: InputMaybe<Scalars["String"]["input"]>;
  is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  monthly_amount?: InputMaybe<Scalars["numeric"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate stddev on columns */
export type CustomerSubscriptionPlansStddevFields = {
  __typename?: "customer_subscription_plans_stddev_fields";
  annual_amount?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  interval?: Maybe<Scalars["Float"]["output"]>;
  monthly_amount?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type CustomerSubscriptionPlansStddevPopFields = {
  __typename?: "customer_subscription_plans_stddev_pop_fields";
  annual_amount?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  interval?: Maybe<Scalars["Float"]["output"]>;
  monthly_amount?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type CustomerSubscriptionPlansStddevSampFields = {
  __typename?: "customer_subscription_plans_stddev_samp_fields";
  annual_amount?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  interval?: Maybe<Scalars["Float"]["output"]>;
  monthly_amount?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "customer_subscription_plans" */
export type CustomerSubscriptionPlansStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CustomerSubscriptionPlansStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CustomerSubscriptionPlansStreamCursorValueInput = {
  annual_amount?: InputMaybe<Scalars["numeric"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  currency?: InputMaybe<Scalars["String"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  external_plan_id?: InputMaybe<Scalars["String"]["input"]>;
  features?: InputMaybe<Scalars["jsonb"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  interval?: InputMaybe<Scalars["Int"]["input"]>;
  interval_type?: InputMaybe<Scalars["String"]["input"]>;
  is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  monthly_amount?: InputMaybe<Scalars["numeric"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate sum on columns */
export type CustomerSubscriptionPlansSumFields = {
  __typename?: "customer_subscription_plans_sum_fields";
  annual_amount?: Maybe<Scalars["numeric"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  interval?: Maybe<Scalars["Int"]["output"]>;
  monthly_amount?: Maybe<Scalars["numeric"]["output"]>;
};

/** update columns of table "customer_subscription_plans" */
export enum CustomerSubscriptionPlansUpdateColumn {
  /** column name */
  ANNUAL_AMOUNT = "annual_amount",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  CURRENCY = "currency",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  EXTERNAL_PLAN_ID = "external_plan_id",
  /** column name */
  FEATURES = "features",
  /** column name */
  ID = "id",
  /** column name */
  INTERVAL = "interval",
  /** column name */
  INTERVAL_TYPE = "interval_type",
  /** column name */
  IS_ACTIVE = "is_active",
  /** column name */
  MONTHLY_AMOUNT = "monthly_amount",
  /** column name */
  NAME = "name",
  /** column name */
  UPDATED_AT = "updated_at",
}

export type CustomerSubscriptionPlansUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<CustomerSubscriptionPlansAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<CustomerSubscriptionPlansDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<CustomerSubscriptionPlansDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<CustomerSubscriptionPlansDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<CustomerSubscriptionPlansIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<CustomerSubscriptionPlansPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CustomerSubscriptionPlansSetInput>;
  /** filter the rows which have to be updated */
  where: CustomerSubscriptionPlansBoolExp;
};

/** aggregate var_pop on columns */
export type CustomerSubscriptionPlansVarPopFields = {
  __typename?: "customer_subscription_plans_var_pop_fields";
  annual_amount?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  interval?: Maybe<Scalars["Float"]["output"]>;
  monthly_amount?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type CustomerSubscriptionPlansVarSampFields = {
  __typename?: "customer_subscription_plans_var_samp_fields";
  annual_amount?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  interval?: Maybe<Scalars["Float"]["output"]>;
  monthly_amount?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type CustomerSubscriptionPlansVarianceFields = {
  __typename?: "customer_subscription_plans_variance_fields";
  annual_amount?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  interval?: Maybe<Scalars["Float"]["output"]>;
  monthly_amount?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "customer_subscriptions" */
export type CustomerSubscriptions = {
  __typename?: "customer_subscriptions";
  auth_attempts?: Maybe<Scalars["Int"]["output"]>;
  cancel_at_period_end?: Maybe<Scalars["Boolean"]["output"]>;
  cancel_initiated_by?: Maybe<Scalars["String"]["output"]>;
  change_scheduled_at?: Maybe<Scalars["timestamptz"]["output"]>;
  charge_at?: Maybe<Scalars["timestamptz"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  current_end: Scalars["timestamptz"]["output"];
  current_start: Scalars["timestamptz"]["output"];
  customer_notify?: Maybe<Scalars["Boolean"]["output"]>;
  /** An array relationship */
  customer_payments: Array<CustomerPayments>;
  /** An aggregate relationship */
  customer_payments_aggregate: CustomerPaymentsAggregate;
  /** An object relationship */
  customer_subscription_plan: CustomerSubscriptionPlans;
  end_at?: Maybe<Scalars["timestamptz"]["output"]>;
  ended_at?: Maybe<Scalars["timestamptz"]["output"]>;
  expire_by?: Maybe<Scalars["timestamptz"]["output"]>;
  external_subscription_id: Scalars["String"]["output"];
  has_scheduled_changes?: Maybe<Scalars["Boolean"]["output"]>;
  id: Scalars["Int"]["output"];
  notes?: Maybe<Scalars["jsonb"]["output"]>;
  offer_id?: Maybe<Scalars["String"]["output"]>;
  paid_count?: Maybe<Scalars["Int"]["output"]>;
  pause_initiated_by?: Maybe<Scalars["String"]["output"]>;
  /** An object relationship */
  payment_provider: PaymentProviders;
  payment_provider_id: Scalars["Int"]["output"];
  plan_id: Scalars["Int"]["output"];
  quantity?: Maybe<Scalars["Int"]["output"]>;
  remaining_count?: Maybe<Scalars["Int"]["output"]>;
  short_url?: Maybe<Scalars["String"]["output"]>;
  source?: Maybe<Scalars["String"]["output"]>;
  start_at?: Maybe<Scalars["timestamptz"]["output"]>;
  status: Scalars["String"]["output"];
  total_count?: Maybe<Scalars["Int"]["output"]>;
  type?: Maybe<Scalars["Int"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id: Scalars["uuid"]["output"];
  /** An object relationship */
  user_profile: UserProfiles;
};

/** columns and relationships of "customer_subscriptions" */
export type CustomerSubscriptionsCustomerPaymentsArgs = {
  distinct_on?: InputMaybe<Array<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

/** columns and relationships of "customer_subscriptions" */
export type CustomerSubscriptionsCustomerPaymentsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

/** columns and relationships of "customer_subscriptions" */
export type CustomerSubscriptionsNotesArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "customer_subscriptions" */
export type CustomerSubscriptionsAggregate = {
  __typename?: "customer_subscriptions_aggregate";
  aggregate?: Maybe<CustomerSubscriptionsAggregateFields>;
  nodes: Array<CustomerSubscriptions>;
};

export type CustomerSubscriptionsAggregateBoolExp = {
  bool_and?: InputMaybe<CustomerSubscriptionsAggregateBoolExpBoolAnd>;
  bool_or?: InputMaybe<CustomerSubscriptionsAggregateBoolExpBoolOr>;
  count?: InputMaybe<CustomerSubscriptionsAggregateBoolExpCount>;
};

export type CustomerSubscriptionsAggregateBoolExpBoolAnd = {
  arguments: CustomerSubscriptionsSelectColumnCustomerSubscriptionsAggregateBoolExpBoolAndArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CustomerSubscriptionsBoolExp>;
  predicate: BooleanComparisonExp;
};

export type CustomerSubscriptionsAggregateBoolExpBoolOr = {
  arguments: CustomerSubscriptionsSelectColumnCustomerSubscriptionsAggregateBoolExpBoolOrArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CustomerSubscriptionsBoolExp>;
  predicate: BooleanComparisonExp;
};

export type CustomerSubscriptionsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<CustomerSubscriptionsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<CustomerSubscriptionsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "customer_subscriptions" */
export type CustomerSubscriptionsAggregateFields = {
  __typename?: "customer_subscriptions_aggregate_fields";
  avg?: Maybe<CustomerSubscriptionsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<CustomerSubscriptionsMaxFields>;
  min?: Maybe<CustomerSubscriptionsMinFields>;
  stddev?: Maybe<CustomerSubscriptionsStddevFields>;
  stddev_pop?: Maybe<CustomerSubscriptionsStddevPopFields>;
  stddev_samp?: Maybe<CustomerSubscriptionsStddevSampFields>;
  sum?: Maybe<CustomerSubscriptionsSumFields>;
  var_pop?: Maybe<CustomerSubscriptionsVarPopFields>;
  var_samp?: Maybe<CustomerSubscriptionsVarSampFields>;
  variance?: Maybe<CustomerSubscriptionsVarianceFields>;
};

/** aggregate fields of "customer_subscriptions" */
export type CustomerSubscriptionsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<CustomerSubscriptionsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "customer_subscriptions" */
export type CustomerSubscriptionsAggregateOrderBy = {
  avg?: InputMaybe<CustomerSubscriptionsAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<CustomerSubscriptionsMaxOrderBy>;
  min?: InputMaybe<CustomerSubscriptionsMinOrderBy>;
  stddev?: InputMaybe<CustomerSubscriptionsStddevOrderBy>;
  stddev_pop?: InputMaybe<CustomerSubscriptionsStddevPopOrderBy>;
  stddev_samp?: InputMaybe<CustomerSubscriptionsStddevSampOrderBy>;
  sum?: InputMaybe<CustomerSubscriptionsSumOrderBy>;
  var_pop?: InputMaybe<CustomerSubscriptionsVarPopOrderBy>;
  var_samp?: InputMaybe<CustomerSubscriptionsVarSampOrderBy>;
  variance?: InputMaybe<CustomerSubscriptionsVarianceOrderBy>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type CustomerSubscriptionsAppendInput = {
  notes?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** input type for inserting array relation for remote table "customer_subscriptions" */
export type CustomerSubscriptionsArrRelInsertInput = {
  data: Array<CustomerSubscriptionsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<CustomerSubscriptionsOnConflict>;
};

/** aggregate avg on columns */
export type CustomerSubscriptionsAvgFields = {
  __typename?: "customer_subscriptions_avg_fields";
  auth_attempts?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  paid_count?: Maybe<Scalars["Float"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  plan_id?: Maybe<Scalars["Float"]["output"]>;
  quantity?: Maybe<Scalars["Float"]["output"]>;
  remaining_count?: Maybe<Scalars["Float"]["output"]>;
  total_count?: Maybe<Scalars["Float"]["output"]>;
  type?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "customer_subscriptions" */
export type CustomerSubscriptionsAvgOrderBy = {
  auth_attempts?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  paid_count?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  plan_id?: InputMaybe<OrderBy>;
  quantity?: InputMaybe<OrderBy>;
  remaining_count?: InputMaybe<OrderBy>;
  total_count?: InputMaybe<OrderBy>;
  type?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "customer_subscriptions". All fields are combined with a logical 'AND'. */
export type CustomerSubscriptionsBoolExp = {
  _and?: InputMaybe<Array<CustomerSubscriptionsBoolExp>>;
  _not?: InputMaybe<CustomerSubscriptionsBoolExp>;
  _or?: InputMaybe<Array<CustomerSubscriptionsBoolExp>>;
  auth_attempts?: InputMaybe<IntComparisonExp>;
  cancel_at_period_end?: InputMaybe<BooleanComparisonExp>;
  cancel_initiated_by?: InputMaybe<StringComparisonExp>;
  change_scheduled_at?: InputMaybe<TimestamptzComparisonExp>;
  charge_at?: InputMaybe<TimestamptzComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  current_end?: InputMaybe<TimestamptzComparisonExp>;
  current_start?: InputMaybe<TimestamptzComparisonExp>;
  customer_notify?: InputMaybe<BooleanComparisonExp>;
  customer_payments?: InputMaybe<CustomerPaymentsBoolExp>;
  customer_payments_aggregate?: InputMaybe<CustomerPaymentsAggregateBoolExp>;
  customer_subscription_plan?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
  end_at?: InputMaybe<TimestamptzComparisonExp>;
  ended_at?: InputMaybe<TimestamptzComparisonExp>;
  expire_by?: InputMaybe<TimestamptzComparisonExp>;
  external_subscription_id?: InputMaybe<StringComparisonExp>;
  has_scheduled_changes?: InputMaybe<BooleanComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  notes?: InputMaybe<JsonbComparisonExp>;
  offer_id?: InputMaybe<StringComparisonExp>;
  paid_count?: InputMaybe<IntComparisonExp>;
  pause_initiated_by?: InputMaybe<StringComparisonExp>;
  payment_provider?: InputMaybe<PaymentProvidersBoolExp>;
  payment_provider_id?: InputMaybe<IntComparisonExp>;
  plan_id?: InputMaybe<IntComparisonExp>;
  quantity?: InputMaybe<IntComparisonExp>;
  remaining_count?: InputMaybe<IntComparisonExp>;
  short_url?: InputMaybe<StringComparisonExp>;
  source?: InputMaybe<StringComparisonExp>;
  start_at?: InputMaybe<TimestamptzComparisonExp>;
  status?: InputMaybe<StringComparisonExp>;
  total_count?: InputMaybe<IntComparisonExp>;
  type?: InputMaybe<IntComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
  user_profile?: InputMaybe<UserProfilesBoolExp>;
};

/** unique or primary key constraints on table "customer_subscriptions" */
export enum CustomerSubscriptionsConstraint {
  /** unique or primary key constraint on columns "id" */
  CUSTOMER_SUBSCRIPTIONS_PKEY = "customer_subscriptions_pkey",
  /** unique or primary key constraint on columns "external_subscription_id" */
  UQ_SUBSCRIPTION_ID = "uq_subscription_id",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type CustomerSubscriptionsDeleteAtPathInput = {
  notes?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type CustomerSubscriptionsDeleteElemInput = {
  notes?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type CustomerSubscriptionsDeleteKeyInput = {
  notes?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for incrementing numeric columns in table "customer_subscriptions" */
export type CustomerSubscriptionsIncInput = {
  auth_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  paid_count?: InputMaybe<Scalars["Int"]["input"]>;
  payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  plan_id?: InputMaybe<Scalars["Int"]["input"]>;
  quantity?: InputMaybe<Scalars["Int"]["input"]>;
  remaining_count?: InputMaybe<Scalars["Int"]["input"]>;
  total_count?: InputMaybe<Scalars["Int"]["input"]>;
  type?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "customer_subscriptions" */
export type CustomerSubscriptionsInsertInput = {
  auth_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  cancel_at_period_end?: InputMaybe<Scalars["Boolean"]["input"]>;
  cancel_initiated_by?: InputMaybe<Scalars["String"]["input"]>;
  change_scheduled_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  charge_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  current_end?: InputMaybe<Scalars["timestamptz"]["input"]>;
  current_start?: InputMaybe<Scalars["timestamptz"]["input"]>;
  customer_notify?: InputMaybe<Scalars["Boolean"]["input"]>;
  customer_payments?: InputMaybe<CustomerPaymentsArrRelInsertInput>;
  customer_subscription_plan?: InputMaybe<CustomerSubscriptionPlansObjRelInsertInput>;
  end_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  ended_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  expire_by?: InputMaybe<Scalars["timestamptz"]["input"]>;
  external_subscription_id?: InputMaybe<Scalars["String"]["input"]>;
  has_scheduled_changes?: InputMaybe<Scalars["Boolean"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  offer_id?: InputMaybe<Scalars["String"]["input"]>;
  paid_count?: InputMaybe<Scalars["Int"]["input"]>;
  pause_initiated_by?: InputMaybe<Scalars["String"]["input"]>;
  payment_provider?: InputMaybe<PaymentProvidersObjRelInsertInput>;
  payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  plan_id?: InputMaybe<Scalars["Int"]["input"]>;
  quantity?: InputMaybe<Scalars["Int"]["input"]>;
  remaining_count?: InputMaybe<Scalars["Int"]["input"]>;
  short_url?: InputMaybe<Scalars["String"]["input"]>;
  source?: InputMaybe<Scalars["String"]["input"]>;
  start_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  status?: InputMaybe<Scalars["String"]["input"]>;
  total_count?: InputMaybe<Scalars["Int"]["input"]>;
  type?: InputMaybe<Scalars["Int"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
};

/** aggregate max on columns */
export type CustomerSubscriptionsMaxFields = {
  __typename?: "customer_subscriptions_max_fields";
  auth_attempts?: Maybe<Scalars["Int"]["output"]>;
  cancel_initiated_by?: Maybe<Scalars["String"]["output"]>;
  change_scheduled_at?: Maybe<Scalars["timestamptz"]["output"]>;
  charge_at?: Maybe<Scalars["timestamptz"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  current_end?: Maybe<Scalars["timestamptz"]["output"]>;
  current_start?: Maybe<Scalars["timestamptz"]["output"]>;
  end_at?: Maybe<Scalars["timestamptz"]["output"]>;
  ended_at?: Maybe<Scalars["timestamptz"]["output"]>;
  expire_by?: Maybe<Scalars["timestamptz"]["output"]>;
  external_subscription_id?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  offer_id?: Maybe<Scalars["String"]["output"]>;
  paid_count?: Maybe<Scalars["Int"]["output"]>;
  pause_initiated_by?: Maybe<Scalars["String"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Int"]["output"]>;
  plan_id?: Maybe<Scalars["Int"]["output"]>;
  quantity?: Maybe<Scalars["Int"]["output"]>;
  remaining_count?: Maybe<Scalars["Int"]["output"]>;
  short_url?: Maybe<Scalars["String"]["output"]>;
  source?: Maybe<Scalars["String"]["output"]>;
  start_at?: Maybe<Scalars["timestamptz"]["output"]>;
  status?: Maybe<Scalars["String"]["output"]>;
  total_count?: Maybe<Scalars["Int"]["output"]>;
  type?: Maybe<Scalars["Int"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by max() on columns of table "customer_subscriptions" */
export type CustomerSubscriptionsMaxOrderBy = {
  auth_attempts?: InputMaybe<OrderBy>;
  cancel_initiated_by?: InputMaybe<OrderBy>;
  change_scheduled_at?: InputMaybe<OrderBy>;
  charge_at?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  current_end?: InputMaybe<OrderBy>;
  current_start?: InputMaybe<OrderBy>;
  end_at?: InputMaybe<OrderBy>;
  ended_at?: InputMaybe<OrderBy>;
  expire_by?: InputMaybe<OrderBy>;
  external_subscription_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  offer_id?: InputMaybe<OrderBy>;
  paid_count?: InputMaybe<OrderBy>;
  pause_initiated_by?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  plan_id?: InputMaybe<OrderBy>;
  quantity?: InputMaybe<OrderBy>;
  remaining_count?: InputMaybe<OrderBy>;
  short_url?: InputMaybe<OrderBy>;
  source?: InputMaybe<OrderBy>;
  start_at?: InputMaybe<OrderBy>;
  status?: InputMaybe<OrderBy>;
  total_count?: InputMaybe<OrderBy>;
  type?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type CustomerSubscriptionsMinFields = {
  __typename?: "customer_subscriptions_min_fields";
  auth_attempts?: Maybe<Scalars["Int"]["output"]>;
  cancel_initiated_by?: Maybe<Scalars["String"]["output"]>;
  change_scheduled_at?: Maybe<Scalars["timestamptz"]["output"]>;
  charge_at?: Maybe<Scalars["timestamptz"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  current_end?: Maybe<Scalars["timestamptz"]["output"]>;
  current_start?: Maybe<Scalars["timestamptz"]["output"]>;
  end_at?: Maybe<Scalars["timestamptz"]["output"]>;
  ended_at?: Maybe<Scalars["timestamptz"]["output"]>;
  expire_by?: Maybe<Scalars["timestamptz"]["output"]>;
  external_subscription_id?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  offer_id?: Maybe<Scalars["String"]["output"]>;
  paid_count?: Maybe<Scalars["Int"]["output"]>;
  pause_initiated_by?: Maybe<Scalars["String"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Int"]["output"]>;
  plan_id?: Maybe<Scalars["Int"]["output"]>;
  quantity?: Maybe<Scalars["Int"]["output"]>;
  remaining_count?: Maybe<Scalars["Int"]["output"]>;
  short_url?: Maybe<Scalars["String"]["output"]>;
  source?: Maybe<Scalars["String"]["output"]>;
  start_at?: Maybe<Scalars["timestamptz"]["output"]>;
  status?: Maybe<Scalars["String"]["output"]>;
  total_count?: Maybe<Scalars["Int"]["output"]>;
  type?: Maybe<Scalars["Int"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by min() on columns of table "customer_subscriptions" */
export type CustomerSubscriptionsMinOrderBy = {
  auth_attempts?: InputMaybe<OrderBy>;
  cancel_initiated_by?: InputMaybe<OrderBy>;
  change_scheduled_at?: InputMaybe<OrderBy>;
  charge_at?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  current_end?: InputMaybe<OrderBy>;
  current_start?: InputMaybe<OrderBy>;
  end_at?: InputMaybe<OrderBy>;
  ended_at?: InputMaybe<OrderBy>;
  expire_by?: InputMaybe<OrderBy>;
  external_subscription_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  offer_id?: InputMaybe<OrderBy>;
  paid_count?: InputMaybe<OrderBy>;
  pause_initiated_by?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  plan_id?: InputMaybe<OrderBy>;
  quantity?: InputMaybe<OrderBy>;
  remaining_count?: InputMaybe<OrderBy>;
  short_url?: InputMaybe<OrderBy>;
  source?: InputMaybe<OrderBy>;
  start_at?: InputMaybe<OrderBy>;
  status?: InputMaybe<OrderBy>;
  total_count?: InputMaybe<OrderBy>;
  type?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "customer_subscriptions" */
export type CustomerSubscriptionsMutationResponse = {
  __typename?: "customer_subscriptions_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<CustomerSubscriptions>;
};

/** input type for inserting object relation for remote table "customer_subscriptions" */
export type CustomerSubscriptionsObjRelInsertInput = {
  data: CustomerSubscriptionsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<CustomerSubscriptionsOnConflict>;
};

/** on_conflict condition type for table "customer_subscriptions" */
export type CustomerSubscriptionsOnConflict = {
  constraint: CustomerSubscriptionsConstraint;
  update_columns?: Array<CustomerSubscriptionsUpdateColumn>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

/** Ordering options when selecting data from "customer_subscriptions". */
export type CustomerSubscriptionsOrderBy = {
  auth_attempts?: InputMaybe<OrderBy>;
  cancel_at_period_end?: InputMaybe<OrderBy>;
  cancel_initiated_by?: InputMaybe<OrderBy>;
  change_scheduled_at?: InputMaybe<OrderBy>;
  charge_at?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  current_end?: InputMaybe<OrderBy>;
  current_start?: InputMaybe<OrderBy>;
  customer_notify?: InputMaybe<OrderBy>;
  customer_payments_aggregate?: InputMaybe<CustomerPaymentsAggregateOrderBy>;
  customer_subscription_plan?: InputMaybe<CustomerSubscriptionPlansOrderBy>;
  end_at?: InputMaybe<OrderBy>;
  ended_at?: InputMaybe<OrderBy>;
  expire_by?: InputMaybe<OrderBy>;
  external_subscription_id?: InputMaybe<OrderBy>;
  has_scheduled_changes?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  notes?: InputMaybe<OrderBy>;
  offer_id?: InputMaybe<OrderBy>;
  paid_count?: InputMaybe<OrderBy>;
  pause_initiated_by?: InputMaybe<OrderBy>;
  payment_provider?: InputMaybe<PaymentProvidersOrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  plan_id?: InputMaybe<OrderBy>;
  quantity?: InputMaybe<OrderBy>;
  remaining_count?: InputMaybe<OrderBy>;
  short_url?: InputMaybe<OrderBy>;
  source?: InputMaybe<OrderBy>;
  start_at?: InputMaybe<OrderBy>;
  status?: InputMaybe<OrderBy>;
  total_count?: InputMaybe<OrderBy>;
  type?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  user_profile?: InputMaybe<UserProfilesOrderBy>;
};

/** primary key columns input for table: customer_subscriptions */
export type CustomerSubscriptionsPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type CustomerSubscriptionsPrependInput = {
  notes?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "customer_subscriptions" */
export enum CustomerSubscriptionsSelectColumn {
  /** column name */
  AUTH_ATTEMPTS = "auth_attempts",
  /** column name */
  CANCEL_AT_PERIOD_END = "cancel_at_period_end",
  /** column name */
  CANCEL_INITIATED_BY = "cancel_initiated_by",
  /** column name */
  CHANGE_SCHEDULED_AT = "change_scheduled_at",
  /** column name */
  CHARGE_AT = "charge_at",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  CURRENT_END = "current_end",
  /** column name */
  CURRENT_START = "current_start",
  /** column name */
  CUSTOMER_NOTIFY = "customer_notify",
  /** column name */
  END_AT = "end_at",
  /** column name */
  ENDED_AT = "ended_at",
  /** column name */
  EXPIRE_BY = "expire_by",
  /** column name */
  EXTERNAL_SUBSCRIPTION_ID = "external_subscription_id",
  /** column name */
  HAS_SCHEDULED_CHANGES = "has_scheduled_changes",
  /** column name */
  ID = "id",
  /** column name */
  NOTES = "notes",
  /** column name */
  OFFER_ID = "offer_id",
  /** column name */
  PAID_COUNT = "paid_count",
  /** column name */
  PAUSE_INITIATED_BY = "pause_initiated_by",
  /** column name */
  PAYMENT_PROVIDER_ID = "payment_provider_id",
  /** column name */
  PLAN_ID = "plan_id",
  /** column name */
  QUANTITY = "quantity",
  /** column name */
  REMAINING_COUNT = "remaining_count",
  /** column name */
  SHORT_URL = "short_url",
  /** column name */
  SOURCE = "source",
  /** column name */
  START_AT = "start_at",
  /** column name */
  STATUS = "status",
  /** column name */
  TOTAL_COUNT = "total_count",
  /** column name */
  TYPE = "type",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

/** select "customer_subscriptions_aggregate_bool_exp_bool_and_arguments_columns" columns of table "customer_subscriptions" */
export enum CustomerSubscriptionsSelectColumnCustomerSubscriptionsAggregateBoolExpBoolAndArgumentsColumns {
  /** column name */
  CANCEL_AT_PERIOD_END = "cancel_at_period_end",
  /** column name */
  CUSTOMER_NOTIFY = "customer_notify",
  /** column name */
  HAS_SCHEDULED_CHANGES = "has_scheduled_changes",
}

/** select "customer_subscriptions_aggregate_bool_exp_bool_or_arguments_columns" columns of table "customer_subscriptions" */
export enum CustomerSubscriptionsSelectColumnCustomerSubscriptionsAggregateBoolExpBoolOrArgumentsColumns {
  /** column name */
  CANCEL_AT_PERIOD_END = "cancel_at_period_end",
  /** column name */
  CUSTOMER_NOTIFY = "customer_notify",
  /** column name */
  HAS_SCHEDULED_CHANGES = "has_scheduled_changes",
}

/** input type for updating data in table "customer_subscriptions" */
export type CustomerSubscriptionsSetInput = {
  auth_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  cancel_at_period_end?: InputMaybe<Scalars["Boolean"]["input"]>;
  cancel_initiated_by?: InputMaybe<Scalars["String"]["input"]>;
  change_scheduled_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  charge_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  current_end?: InputMaybe<Scalars["timestamptz"]["input"]>;
  current_start?: InputMaybe<Scalars["timestamptz"]["input"]>;
  customer_notify?: InputMaybe<Scalars["Boolean"]["input"]>;
  end_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  ended_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  expire_by?: InputMaybe<Scalars["timestamptz"]["input"]>;
  external_subscription_id?: InputMaybe<Scalars["String"]["input"]>;
  has_scheduled_changes?: InputMaybe<Scalars["Boolean"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  offer_id?: InputMaybe<Scalars["String"]["input"]>;
  paid_count?: InputMaybe<Scalars["Int"]["input"]>;
  pause_initiated_by?: InputMaybe<Scalars["String"]["input"]>;
  payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  plan_id?: InputMaybe<Scalars["Int"]["input"]>;
  quantity?: InputMaybe<Scalars["Int"]["input"]>;
  remaining_count?: InputMaybe<Scalars["Int"]["input"]>;
  short_url?: InputMaybe<Scalars["String"]["input"]>;
  source?: InputMaybe<Scalars["String"]["input"]>;
  start_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  status?: InputMaybe<Scalars["String"]["input"]>;
  total_count?: InputMaybe<Scalars["Int"]["input"]>;
  type?: InputMaybe<Scalars["Int"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate stddev on columns */
export type CustomerSubscriptionsStddevFields = {
  __typename?: "customer_subscriptions_stddev_fields";
  auth_attempts?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  paid_count?: Maybe<Scalars["Float"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  plan_id?: Maybe<Scalars["Float"]["output"]>;
  quantity?: Maybe<Scalars["Float"]["output"]>;
  remaining_count?: Maybe<Scalars["Float"]["output"]>;
  total_count?: Maybe<Scalars["Float"]["output"]>;
  type?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "customer_subscriptions" */
export type CustomerSubscriptionsStddevOrderBy = {
  auth_attempts?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  paid_count?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  plan_id?: InputMaybe<OrderBy>;
  quantity?: InputMaybe<OrderBy>;
  remaining_count?: InputMaybe<OrderBy>;
  total_count?: InputMaybe<OrderBy>;
  type?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type CustomerSubscriptionsStddevPopFields = {
  __typename?: "customer_subscriptions_stddev_pop_fields";
  auth_attempts?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  paid_count?: Maybe<Scalars["Float"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  plan_id?: Maybe<Scalars["Float"]["output"]>;
  quantity?: Maybe<Scalars["Float"]["output"]>;
  remaining_count?: Maybe<Scalars["Float"]["output"]>;
  total_count?: Maybe<Scalars["Float"]["output"]>;
  type?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "customer_subscriptions" */
export type CustomerSubscriptionsStddevPopOrderBy = {
  auth_attempts?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  paid_count?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  plan_id?: InputMaybe<OrderBy>;
  quantity?: InputMaybe<OrderBy>;
  remaining_count?: InputMaybe<OrderBy>;
  total_count?: InputMaybe<OrderBy>;
  type?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type CustomerSubscriptionsStddevSampFields = {
  __typename?: "customer_subscriptions_stddev_samp_fields";
  auth_attempts?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  paid_count?: Maybe<Scalars["Float"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  plan_id?: Maybe<Scalars["Float"]["output"]>;
  quantity?: Maybe<Scalars["Float"]["output"]>;
  remaining_count?: Maybe<Scalars["Float"]["output"]>;
  total_count?: Maybe<Scalars["Float"]["output"]>;
  type?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "customer_subscriptions" */
export type CustomerSubscriptionsStddevSampOrderBy = {
  auth_attempts?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  paid_count?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  plan_id?: InputMaybe<OrderBy>;
  quantity?: InputMaybe<OrderBy>;
  remaining_count?: InputMaybe<OrderBy>;
  total_count?: InputMaybe<OrderBy>;
  type?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "customer_subscriptions" */
export type CustomerSubscriptionsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: CustomerSubscriptionsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type CustomerSubscriptionsStreamCursorValueInput = {
  auth_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  cancel_at_period_end?: InputMaybe<Scalars["Boolean"]["input"]>;
  cancel_initiated_by?: InputMaybe<Scalars["String"]["input"]>;
  change_scheduled_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  charge_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  current_end?: InputMaybe<Scalars["timestamptz"]["input"]>;
  current_start?: InputMaybe<Scalars["timestamptz"]["input"]>;
  customer_notify?: InputMaybe<Scalars["Boolean"]["input"]>;
  end_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  ended_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  expire_by?: InputMaybe<Scalars["timestamptz"]["input"]>;
  external_subscription_id?: InputMaybe<Scalars["String"]["input"]>;
  has_scheduled_changes?: InputMaybe<Scalars["Boolean"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  offer_id?: InputMaybe<Scalars["String"]["input"]>;
  paid_count?: InputMaybe<Scalars["Int"]["input"]>;
  pause_initiated_by?: InputMaybe<Scalars["String"]["input"]>;
  payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  plan_id?: InputMaybe<Scalars["Int"]["input"]>;
  quantity?: InputMaybe<Scalars["Int"]["input"]>;
  remaining_count?: InputMaybe<Scalars["Int"]["input"]>;
  short_url?: InputMaybe<Scalars["String"]["input"]>;
  source?: InputMaybe<Scalars["String"]["input"]>;
  start_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  status?: InputMaybe<Scalars["String"]["input"]>;
  total_count?: InputMaybe<Scalars["Int"]["input"]>;
  type?: InputMaybe<Scalars["Int"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate sum on columns */
export type CustomerSubscriptionsSumFields = {
  __typename?: "customer_subscriptions_sum_fields";
  auth_attempts?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  paid_count?: Maybe<Scalars["Int"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Int"]["output"]>;
  plan_id?: Maybe<Scalars["Int"]["output"]>;
  quantity?: Maybe<Scalars["Int"]["output"]>;
  remaining_count?: Maybe<Scalars["Int"]["output"]>;
  total_count?: Maybe<Scalars["Int"]["output"]>;
  type?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "customer_subscriptions" */
export type CustomerSubscriptionsSumOrderBy = {
  auth_attempts?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  paid_count?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  plan_id?: InputMaybe<OrderBy>;
  quantity?: InputMaybe<OrderBy>;
  remaining_count?: InputMaybe<OrderBy>;
  total_count?: InputMaybe<OrderBy>;
  type?: InputMaybe<OrderBy>;
};

/** update columns of table "customer_subscriptions" */
export enum CustomerSubscriptionsUpdateColumn {
  /** column name */
  AUTH_ATTEMPTS = "auth_attempts",
  /** column name */
  CANCEL_AT_PERIOD_END = "cancel_at_period_end",
  /** column name */
  CANCEL_INITIATED_BY = "cancel_initiated_by",
  /** column name */
  CHANGE_SCHEDULED_AT = "change_scheduled_at",
  /** column name */
  CHARGE_AT = "charge_at",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  CURRENT_END = "current_end",
  /** column name */
  CURRENT_START = "current_start",
  /** column name */
  CUSTOMER_NOTIFY = "customer_notify",
  /** column name */
  END_AT = "end_at",
  /** column name */
  ENDED_AT = "ended_at",
  /** column name */
  EXPIRE_BY = "expire_by",
  /** column name */
  EXTERNAL_SUBSCRIPTION_ID = "external_subscription_id",
  /** column name */
  HAS_SCHEDULED_CHANGES = "has_scheduled_changes",
  /** column name */
  ID = "id",
  /** column name */
  NOTES = "notes",
  /** column name */
  OFFER_ID = "offer_id",
  /** column name */
  PAID_COUNT = "paid_count",
  /** column name */
  PAUSE_INITIATED_BY = "pause_initiated_by",
  /** column name */
  PAYMENT_PROVIDER_ID = "payment_provider_id",
  /** column name */
  PLAN_ID = "plan_id",
  /** column name */
  QUANTITY = "quantity",
  /** column name */
  REMAINING_COUNT = "remaining_count",
  /** column name */
  SHORT_URL = "short_url",
  /** column name */
  SOURCE = "source",
  /** column name */
  START_AT = "start_at",
  /** column name */
  STATUS = "status",
  /** column name */
  TOTAL_COUNT = "total_count",
  /** column name */
  TYPE = "type",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

export type CustomerSubscriptionsUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<CustomerSubscriptionsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<CustomerSubscriptionsDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<CustomerSubscriptionsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<CustomerSubscriptionsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<CustomerSubscriptionsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<CustomerSubscriptionsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<CustomerSubscriptionsSetInput>;
  /** filter the rows which have to be updated */
  where: CustomerSubscriptionsBoolExp;
};

/** aggregate var_pop on columns */
export type CustomerSubscriptionsVarPopFields = {
  __typename?: "customer_subscriptions_var_pop_fields";
  auth_attempts?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  paid_count?: Maybe<Scalars["Float"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  plan_id?: Maybe<Scalars["Float"]["output"]>;
  quantity?: Maybe<Scalars["Float"]["output"]>;
  remaining_count?: Maybe<Scalars["Float"]["output"]>;
  total_count?: Maybe<Scalars["Float"]["output"]>;
  type?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "customer_subscriptions" */
export type CustomerSubscriptionsVarPopOrderBy = {
  auth_attempts?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  paid_count?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  plan_id?: InputMaybe<OrderBy>;
  quantity?: InputMaybe<OrderBy>;
  remaining_count?: InputMaybe<OrderBy>;
  total_count?: InputMaybe<OrderBy>;
  type?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type CustomerSubscriptionsVarSampFields = {
  __typename?: "customer_subscriptions_var_samp_fields";
  auth_attempts?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  paid_count?: Maybe<Scalars["Float"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  plan_id?: Maybe<Scalars["Float"]["output"]>;
  quantity?: Maybe<Scalars["Float"]["output"]>;
  remaining_count?: Maybe<Scalars["Float"]["output"]>;
  total_count?: Maybe<Scalars["Float"]["output"]>;
  type?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "customer_subscriptions" */
export type CustomerSubscriptionsVarSampOrderBy = {
  auth_attempts?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  paid_count?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  plan_id?: InputMaybe<OrderBy>;
  quantity?: InputMaybe<OrderBy>;
  remaining_count?: InputMaybe<OrderBy>;
  total_count?: InputMaybe<OrderBy>;
  type?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type CustomerSubscriptionsVarianceFields = {
  __typename?: "customer_subscriptions_variance_fields";
  auth_attempts?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  paid_count?: Maybe<Scalars["Float"]["output"]>;
  payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  plan_id?: Maybe<Scalars["Float"]["output"]>;
  quantity?: Maybe<Scalars["Float"]["output"]>;
  remaining_count?: Maybe<Scalars["Float"]["output"]>;
  total_count?: Maybe<Scalars["Float"]["output"]>;
  type?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "customer_subscriptions" */
export type CustomerSubscriptionsVarianceOrderBy = {
  auth_attempts?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  paid_count?: InputMaybe<OrderBy>;
  payment_provider_id?: InputMaybe<OrderBy>;
  plan_id?: InputMaybe<OrderBy>;
  quantity?: InputMaybe<OrderBy>;
  remaining_count?: InputMaybe<OrderBy>;
  total_count?: InputMaybe<OrderBy>;
  type?: InputMaybe<OrderBy>;
};

/** Boolean expression to compare columns of type "date". All fields are combined with logical 'AND'. */
export type DateComparisonExp = {
  _eq?: InputMaybe<Scalars["date"]["input"]>;
  _gt?: InputMaybe<Scalars["date"]["input"]>;
  _gte?: InputMaybe<Scalars["date"]["input"]>;
  _in?: InputMaybe<Array<Scalars["date"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["date"]["input"]>;
  _lte?: InputMaybe<Scalars["date"]["input"]>;
  _neq?: InputMaybe<Scalars["date"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["date"]["input"]>>;
};

/** columns and relationships of "embedding_reviews" */
export type EmbeddingReviews = {
  __typename?: "embedding_reviews";
  agent_review?: Maybe<Scalars["Boolean"]["output"]>;
  created_at: Scalars["timestamptz"]["output"];
  human_review?: Maybe<Scalars["Boolean"]["output"]>;
  id: Scalars["bigint"]["output"];
  notes?: Maybe<Scalars["String"]["output"]>;
  /** An array relationship */
  research_embeddings: Array<ResearchEmbeddings>;
  /** An aggregate relationship */
  research_embeddings_aggregate: ResearchEmbeddingsAggregate;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** columns and relationships of "embedding_reviews" */
export type EmbeddingReviewsResearchEmbeddingsArgs = {
  distinct_on?: InputMaybe<Array<ResearchEmbeddingsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResearchEmbeddingsOrderBy>>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

/** columns and relationships of "embedding_reviews" */
export type EmbeddingReviewsResearchEmbeddingsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ResearchEmbeddingsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResearchEmbeddingsOrderBy>>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

/** aggregated selection of "embedding_reviews" */
export type EmbeddingReviewsAggregate = {
  __typename?: "embedding_reviews_aggregate";
  aggregate?: Maybe<EmbeddingReviewsAggregateFields>;
  nodes: Array<EmbeddingReviews>;
};

/** aggregate fields of "embedding_reviews" */
export type EmbeddingReviewsAggregateFields = {
  __typename?: "embedding_reviews_aggregate_fields";
  avg?: Maybe<EmbeddingReviewsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<EmbeddingReviewsMaxFields>;
  min?: Maybe<EmbeddingReviewsMinFields>;
  stddev?: Maybe<EmbeddingReviewsStddevFields>;
  stddev_pop?: Maybe<EmbeddingReviewsStddevPopFields>;
  stddev_samp?: Maybe<EmbeddingReviewsStddevSampFields>;
  sum?: Maybe<EmbeddingReviewsSumFields>;
  var_pop?: Maybe<EmbeddingReviewsVarPopFields>;
  var_samp?: Maybe<EmbeddingReviewsVarSampFields>;
  variance?: Maybe<EmbeddingReviewsVarianceFields>;
};

/** aggregate fields of "embedding_reviews" */
export type EmbeddingReviewsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<EmbeddingReviewsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type EmbeddingReviewsAvgFields = {
  __typename?: "embedding_reviews_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "embedding_reviews". All fields are combined with a logical 'AND'. */
export type EmbeddingReviewsBoolExp = {
  _and?: InputMaybe<Array<EmbeddingReviewsBoolExp>>;
  _not?: InputMaybe<EmbeddingReviewsBoolExp>;
  _or?: InputMaybe<Array<EmbeddingReviewsBoolExp>>;
  agent_review?: InputMaybe<BooleanComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  human_review?: InputMaybe<BooleanComparisonExp>;
  id?: InputMaybe<BigintComparisonExp>;
  notes?: InputMaybe<StringComparisonExp>;
  research_embeddings?: InputMaybe<ResearchEmbeddingsBoolExp>;
  research_embeddings_aggregate?: InputMaybe<ResearchEmbeddingsAggregateBoolExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
};

/** unique or primary key constraints on table "embedding_reviews" */
export enum EmbeddingReviewsConstraint {
  /** unique or primary key constraint on columns "id" */
  EMBEDDING_REVIEW_PKEY = "embedding_review_pkey",
}

/** input type for incrementing numeric columns in table "embedding_reviews" */
export type EmbeddingReviewsIncInput = {
  id?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** input type for inserting data into table "embedding_reviews" */
export type EmbeddingReviewsInsertInput = {
  agent_review?: InputMaybe<Scalars["Boolean"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  human_review?: InputMaybe<Scalars["Boolean"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  notes?: InputMaybe<Scalars["String"]["input"]>;
  research_embeddings?: InputMaybe<ResearchEmbeddingsArrRelInsertInput>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate max on columns */
export type EmbeddingReviewsMaxFields = {
  __typename?: "embedding_reviews_max_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  notes?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregate min on columns */
export type EmbeddingReviewsMinFields = {
  __typename?: "embedding_reviews_min_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  notes?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** response of any mutation on the table "embedding_reviews" */
export type EmbeddingReviewsMutationResponse = {
  __typename?: "embedding_reviews_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<EmbeddingReviews>;
};

/** input type for inserting object relation for remote table "embedding_reviews" */
export type EmbeddingReviewsObjRelInsertInput = {
  data: EmbeddingReviewsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<EmbeddingReviewsOnConflict>;
};

/** on_conflict condition type for table "embedding_reviews" */
export type EmbeddingReviewsOnConflict = {
  constraint: EmbeddingReviewsConstraint;
  update_columns?: Array<EmbeddingReviewsUpdateColumn>;
  where?: InputMaybe<EmbeddingReviewsBoolExp>;
};

/** Ordering options when selecting data from "embedding_reviews". */
export type EmbeddingReviewsOrderBy = {
  agent_review?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  human_review?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  notes?: InputMaybe<OrderBy>;
  research_embeddings_aggregate?: InputMaybe<ResearchEmbeddingsAggregateOrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: embedding_reviews */
export type EmbeddingReviewsPkColumnsInput = {
  id: Scalars["bigint"]["input"];
};

/** select columns of table "embedding_reviews" */
export enum EmbeddingReviewsSelectColumn {
  /** column name */
  AGENT_REVIEW = "agent_review",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  HUMAN_REVIEW = "human_review",
  /** column name */
  ID = "id",
  /** column name */
  NOTES = "notes",
  /** column name */
  UPDATED_AT = "updated_at",
}

/** input type for updating data in table "embedding_reviews" */
export type EmbeddingReviewsSetInput = {
  agent_review?: InputMaybe<Scalars["Boolean"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  human_review?: InputMaybe<Scalars["Boolean"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  notes?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate stddev on columns */
export type EmbeddingReviewsStddevFields = {
  __typename?: "embedding_reviews_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type EmbeddingReviewsStddevPopFields = {
  __typename?: "embedding_reviews_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type EmbeddingReviewsStddevSampFields = {
  __typename?: "embedding_reviews_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "embedding_reviews" */
export type EmbeddingReviewsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: EmbeddingReviewsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type EmbeddingReviewsStreamCursorValueInput = {
  agent_review?: InputMaybe<Scalars["Boolean"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  human_review?: InputMaybe<Scalars["Boolean"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  notes?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate sum on columns */
export type EmbeddingReviewsSumFields = {
  __typename?: "embedding_reviews_sum_fields";
  id?: Maybe<Scalars["bigint"]["output"]>;
};

/** update columns of table "embedding_reviews" */
export enum EmbeddingReviewsUpdateColumn {
  /** column name */
  AGENT_REVIEW = "agent_review",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  HUMAN_REVIEW = "human_review",
  /** column name */
  ID = "id",
  /** column name */
  NOTES = "notes",
  /** column name */
  UPDATED_AT = "updated_at",
}

export type EmbeddingReviewsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<EmbeddingReviewsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<EmbeddingReviewsSetInput>;
  /** filter the rows which have to be updated */
  where: EmbeddingReviewsBoolExp;
};

/** aggregate var_pop on columns */
export type EmbeddingReviewsVarPopFields = {
  __typename?: "embedding_reviews_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type EmbeddingReviewsVarSampFields = {
  __typename?: "embedding_reviews_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type EmbeddingReviewsVarianceFields = {
  __typename?: "embedding_reviews_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "error_correlations" */
export type ErrorCorrelations = {
  __typename?: "error_correlations";
  avg_time_difference?: Maybe<Scalars["numeric"]["output"]>;
  correlation_count?: Maybe<Scalars["bigint"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  source_pattern?: Maybe<Scalars["String"]["output"]>;
  source_service?: Maybe<Scalars["String"]["output"]>;
  target_pattern?: Maybe<Scalars["String"]["output"]>;
  target_service?: Maybe<Scalars["String"]["output"]>;
};

/** aggregated selection of "error_correlations" */
export type ErrorCorrelationsAggregate = {
  __typename?: "error_correlations_aggregate";
  aggregate?: Maybe<ErrorCorrelationsAggregateFields>;
  nodes: Array<ErrorCorrelations>;
};

/** aggregate fields of "error_correlations" */
export type ErrorCorrelationsAggregateFields = {
  __typename?: "error_correlations_aggregate_fields";
  avg?: Maybe<ErrorCorrelationsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ErrorCorrelationsMaxFields>;
  min?: Maybe<ErrorCorrelationsMinFields>;
  stddev?: Maybe<ErrorCorrelationsStddevFields>;
  stddev_pop?: Maybe<ErrorCorrelationsStddevPopFields>;
  stddev_samp?: Maybe<ErrorCorrelationsStddevSampFields>;
  sum?: Maybe<ErrorCorrelationsSumFields>;
  var_pop?: Maybe<ErrorCorrelationsVarPopFields>;
  var_samp?: Maybe<ErrorCorrelationsVarSampFields>;
  variance?: Maybe<ErrorCorrelationsVarianceFields>;
};

/** aggregate fields of "error_correlations" */
export type ErrorCorrelationsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ErrorCorrelationsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type ErrorCorrelationsAvgFields = {
  __typename?: "error_correlations_avg_fields";
  avg_time_difference?: Maybe<Scalars["Float"]["output"]>;
  correlation_count?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "error_correlations". All fields are combined with a logical 'AND'. */
export type ErrorCorrelationsBoolExp = {
  _and?: InputMaybe<Array<ErrorCorrelationsBoolExp>>;
  _not?: InputMaybe<ErrorCorrelationsBoolExp>;
  _or?: InputMaybe<Array<ErrorCorrelationsBoolExp>>;
  avg_time_difference?: InputMaybe<NumericComparisonExp>;
  correlation_count?: InputMaybe<BigintComparisonExp>;
  id?: InputMaybe<BigintComparisonExp>;
  source_pattern?: InputMaybe<StringComparisonExp>;
  source_service?: InputMaybe<StringComparisonExp>;
  target_pattern?: InputMaybe<StringComparisonExp>;
  target_service?: InputMaybe<StringComparisonExp>;
};

/** aggregate max on columns */
export type ErrorCorrelationsMaxFields = {
  __typename?: "error_correlations_max_fields";
  avg_time_difference?: Maybe<Scalars["numeric"]["output"]>;
  correlation_count?: Maybe<Scalars["bigint"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  source_pattern?: Maybe<Scalars["String"]["output"]>;
  source_service?: Maybe<Scalars["String"]["output"]>;
  target_pattern?: Maybe<Scalars["String"]["output"]>;
  target_service?: Maybe<Scalars["String"]["output"]>;
};

/** aggregate min on columns */
export type ErrorCorrelationsMinFields = {
  __typename?: "error_correlations_min_fields";
  avg_time_difference?: Maybe<Scalars["numeric"]["output"]>;
  correlation_count?: Maybe<Scalars["bigint"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  source_pattern?: Maybe<Scalars["String"]["output"]>;
  source_service?: Maybe<Scalars["String"]["output"]>;
  target_pattern?: Maybe<Scalars["String"]["output"]>;
  target_service?: Maybe<Scalars["String"]["output"]>;
};

/** Ordering options when selecting data from "error_correlations". */
export type ErrorCorrelationsOrderBy = {
  avg_time_difference?: InputMaybe<OrderBy>;
  correlation_count?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  source_pattern?: InputMaybe<OrderBy>;
  source_service?: InputMaybe<OrderBy>;
  target_pattern?: InputMaybe<OrderBy>;
  target_service?: InputMaybe<OrderBy>;
};

/** select columns of table "error_correlations" */
export enum ErrorCorrelationsSelectColumn {
  /** column name */
  AVG_TIME_DIFFERENCE = "avg_time_difference",
  /** column name */
  CORRELATION_COUNT = "correlation_count",
  /** column name */
  ID = "id",
  /** column name */
  SOURCE_PATTERN = "source_pattern",
  /** column name */
  SOURCE_SERVICE = "source_service",
  /** column name */
  TARGET_PATTERN = "target_pattern",
  /** column name */
  TARGET_SERVICE = "target_service",
}

/** aggregate stddev on columns */
export type ErrorCorrelationsStddevFields = {
  __typename?: "error_correlations_stddev_fields";
  avg_time_difference?: Maybe<Scalars["Float"]["output"]>;
  correlation_count?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type ErrorCorrelationsStddevPopFields = {
  __typename?: "error_correlations_stddev_pop_fields";
  avg_time_difference?: Maybe<Scalars["Float"]["output"]>;
  correlation_count?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type ErrorCorrelationsStddevSampFields = {
  __typename?: "error_correlations_stddev_samp_fields";
  avg_time_difference?: Maybe<Scalars["Float"]["output"]>;
  correlation_count?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "error_correlations" */
export type ErrorCorrelationsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ErrorCorrelationsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ErrorCorrelationsStreamCursorValueInput = {
  avg_time_difference?: InputMaybe<Scalars["numeric"]["input"]>;
  correlation_count?: InputMaybe<Scalars["bigint"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  source_pattern?: InputMaybe<Scalars["String"]["input"]>;
  source_service?: InputMaybe<Scalars["String"]["input"]>;
  target_pattern?: InputMaybe<Scalars["String"]["input"]>;
  target_service?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type ErrorCorrelationsSumFields = {
  __typename?: "error_correlations_sum_fields";
  avg_time_difference?: Maybe<Scalars["numeric"]["output"]>;
  correlation_count?: Maybe<Scalars["bigint"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate var_pop on columns */
export type ErrorCorrelationsVarPopFields = {
  __typename?: "error_correlations_var_pop_fields";
  avg_time_difference?: Maybe<Scalars["Float"]["output"]>;
  correlation_count?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type ErrorCorrelationsVarSampFields = {
  __typename?: "error_correlations_var_samp_fields";
  avg_time_difference?: Maybe<Scalars["Float"]["output"]>;
  correlation_count?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type ErrorCorrelationsVarianceFields = {
  __typename?: "error_correlations_variance_fields";
  avg_time_difference?: Maybe<Scalars["Float"]["output"]>;
  correlation_count?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "error_frequency" */
export type ErrorFrequency = {
  __typename?: "error_frequency";
  error_count?: Maybe<Scalars["bigint"]["output"]>;
  error_type?: Maybe<Scalars["error_type"]["output"]>;
  service_name?: Maybe<Scalars["String"]["output"]>;
  severity?: Maybe<Scalars["error_severity"]["output"]>;
  time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregated selection of "error_frequency" */
export type ErrorFrequencyAggregate = {
  __typename?: "error_frequency_aggregate";
  aggregate?: Maybe<ErrorFrequencyAggregateFields>;
  nodes: Array<ErrorFrequency>;
};

/** aggregate fields of "error_frequency" */
export type ErrorFrequencyAggregateFields = {
  __typename?: "error_frequency_aggregate_fields";
  avg?: Maybe<ErrorFrequencyAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ErrorFrequencyMaxFields>;
  min?: Maybe<ErrorFrequencyMinFields>;
  stddev?: Maybe<ErrorFrequencyStddevFields>;
  stddev_pop?: Maybe<ErrorFrequencyStddevPopFields>;
  stddev_samp?: Maybe<ErrorFrequencyStddevSampFields>;
  sum?: Maybe<ErrorFrequencySumFields>;
  var_pop?: Maybe<ErrorFrequencyVarPopFields>;
  var_samp?: Maybe<ErrorFrequencyVarSampFields>;
  variance?: Maybe<ErrorFrequencyVarianceFields>;
};

/** aggregate fields of "error_frequency" */
export type ErrorFrequencyAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ErrorFrequencySelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type ErrorFrequencyAvgFields = {
  __typename?: "error_frequency_avg_fields";
  error_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "error_frequency". All fields are combined with a logical 'AND'. */
export type ErrorFrequencyBoolExp = {
  _and?: InputMaybe<Array<ErrorFrequencyBoolExp>>;
  _not?: InputMaybe<ErrorFrequencyBoolExp>;
  _or?: InputMaybe<Array<ErrorFrequencyBoolExp>>;
  error_count?: InputMaybe<BigintComparisonExp>;
  error_type?: InputMaybe<ErrorTypeComparisonExp>;
  service_name?: InputMaybe<StringComparisonExp>;
  severity?: InputMaybe<ErrorSeverityComparisonExp>;
  time_bucket?: InputMaybe<TimestamptzComparisonExp>;
};

/** aggregate max on columns */
export type ErrorFrequencyMaxFields = {
  __typename?: "error_frequency_max_fields";
  error_count?: Maybe<Scalars["bigint"]["output"]>;
  error_type?: Maybe<Scalars["error_type"]["output"]>;
  service_name?: Maybe<Scalars["String"]["output"]>;
  severity?: Maybe<Scalars["error_severity"]["output"]>;
  time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregate min on columns */
export type ErrorFrequencyMinFields = {
  __typename?: "error_frequency_min_fields";
  error_count?: Maybe<Scalars["bigint"]["output"]>;
  error_type?: Maybe<Scalars["error_type"]["output"]>;
  service_name?: Maybe<Scalars["String"]["output"]>;
  severity?: Maybe<Scalars["error_severity"]["output"]>;
  time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** Ordering options when selecting data from "error_frequency". */
export type ErrorFrequencyOrderBy = {
  error_count?: InputMaybe<OrderBy>;
  error_type?: InputMaybe<OrderBy>;
  service_name?: InputMaybe<OrderBy>;
  severity?: InputMaybe<OrderBy>;
  time_bucket?: InputMaybe<OrderBy>;
};

/** select columns of table "error_frequency" */
export enum ErrorFrequencySelectColumn {
  /** column name */
  ERROR_COUNT = "error_count",
  /** column name */
  ERROR_TYPE = "error_type",
  /** column name */
  SERVICE_NAME = "service_name",
  /** column name */
  SEVERITY = "severity",
  /** column name */
  TIME_BUCKET = "time_bucket",
}

/** aggregate stddev on columns */
export type ErrorFrequencyStddevFields = {
  __typename?: "error_frequency_stddev_fields";
  error_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type ErrorFrequencyStddevPopFields = {
  __typename?: "error_frequency_stddev_pop_fields";
  error_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type ErrorFrequencyStddevSampFields = {
  __typename?: "error_frequency_stddev_samp_fields";
  error_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "error_frequency" */
export type ErrorFrequencyStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ErrorFrequencyStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ErrorFrequencyStreamCursorValueInput = {
  error_count?: InputMaybe<Scalars["bigint"]["input"]>;
  error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  service_name?: InputMaybe<Scalars["String"]["input"]>;
  severity?: InputMaybe<Scalars["error_severity"]["input"]>;
  time_bucket?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate sum on columns */
export type ErrorFrequencySumFields = {
  __typename?: "error_frequency_sum_fields";
  error_count?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate var_pop on columns */
export type ErrorFrequencyVarPopFields = {
  __typename?: "error_frequency_var_pop_fields";
  error_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type ErrorFrequencyVarSampFields = {
  __typename?: "error_frequency_var_samp_fields";
  error_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type ErrorFrequencyVarianceFields = {
  __typename?: "error_frequency_variance_fields";
  error_count?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "error_logs" */
export type ErrorLogs = {
  __typename?: "error_logs";
  context?: Maybe<Scalars["jsonb"]["output"]>;
  correlation_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  domain?: Maybe<Scalars["String"]["output"]>;
  environment: Scalars["String"]["output"];
  error_hash?: Maybe<Scalars["String"]["output"]>;
  error_pattern?: Maybe<Scalars["String"]["output"]>;
  error_type: Scalars["error_type"]["output"];
  frequency_data?: Maybe<Scalars["jsonb"]["output"]>;
  github_repo?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["uuid"]["output"];
  is_new_pattern?: Maybe<Scalars["Boolean"]["output"]>;
  message: Scalars["String"]["output"];
  metadata?: Maybe<Scalars["jsonb"]["output"]>;
  related_errors?: Maybe<Scalars["jsonb"]["output"]>;
  request_id?: Maybe<Scalars["uuid"]["output"]>;
  service_name: Scalars["String"]["output"];
  severity: Scalars["error_severity"]["output"];
  stack_trace?: Maybe<Scalars["String"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** columns and relationships of "error_logs" */
export type ErrorLogsContextArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "error_logs" */
export type ErrorLogsFrequencyDataArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "error_logs" */
export type ErrorLogsMetadataArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "error_logs" */
export type ErrorLogsRelatedErrorsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "error_logs" */
export type ErrorLogsAggregate = {
  __typename?: "error_logs_aggregate";
  aggregate?: Maybe<ErrorLogsAggregateFields>;
  nodes: Array<ErrorLogs>;
};

/** aggregate fields of "error_logs" */
export type ErrorLogsAggregateFields = {
  __typename?: "error_logs_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<ErrorLogsMaxFields>;
  min?: Maybe<ErrorLogsMinFields>;
};

/** aggregate fields of "error_logs" */
export type ErrorLogsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ErrorLogsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type ErrorLogsAppendInput = {
  context?: InputMaybe<Scalars["jsonb"]["input"]>;
  frequency_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  related_errors?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** Boolean expression to filter rows from the table "error_logs". All fields are combined with a logical 'AND'. */
export type ErrorLogsBoolExp = {
  _and?: InputMaybe<Array<ErrorLogsBoolExp>>;
  _not?: InputMaybe<ErrorLogsBoolExp>;
  _or?: InputMaybe<Array<ErrorLogsBoolExp>>;
  context?: InputMaybe<JsonbComparisonExp>;
  correlation_id?: InputMaybe<UuidComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  domain?: InputMaybe<StringComparisonExp>;
  environment?: InputMaybe<StringComparisonExp>;
  error_hash?: InputMaybe<StringComparisonExp>;
  error_pattern?: InputMaybe<StringComparisonExp>;
  error_type?: InputMaybe<ErrorTypeComparisonExp>;
  frequency_data?: InputMaybe<JsonbComparisonExp>;
  github_repo?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  is_new_pattern?: InputMaybe<BooleanComparisonExp>;
  message?: InputMaybe<StringComparisonExp>;
  metadata?: InputMaybe<JsonbComparisonExp>;
  related_errors?: InputMaybe<JsonbComparisonExp>;
  request_id?: InputMaybe<UuidComparisonExp>;
  service_name?: InputMaybe<StringComparisonExp>;
  severity?: InputMaybe<ErrorSeverityComparisonExp>;
  stack_trace?: InputMaybe<StringComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
};

/** unique or primary key constraints on table "error_logs" */
export enum ErrorLogsConstraint {
  /** unique or primary key constraint on columns "id" */
  ERROR_LOGS_PKEY = "error_logs_pkey",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type ErrorLogsDeleteAtPathInput = {
  context?: InputMaybe<Array<Scalars["String"]["input"]>>;
  frequency_data?: InputMaybe<Array<Scalars["String"]["input"]>>;
  metadata?: InputMaybe<Array<Scalars["String"]["input"]>>;
  related_errors?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type ErrorLogsDeleteElemInput = {
  context?: InputMaybe<Scalars["Int"]["input"]>;
  frequency_data?: InputMaybe<Scalars["Int"]["input"]>;
  metadata?: InputMaybe<Scalars["Int"]["input"]>;
  related_errors?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type ErrorLogsDeleteKeyInput = {
  context?: InputMaybe<Scalars["String"]["input"]>;
  frequency_data?: InputMaybe<Scalars["String"]["input"]>;
  metadata?: InputMaybe<Scalars["String"]["input"]>;
  related_errors?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for inserting data into table "error_logs" */
export type ErrorLogsInsertInput = {
  context?: InputMaybe<Scalars["jsonb"]["input"]>;
  correlation_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  domain?: InputMaybe<Scalars["String"]["input"]>;
  environment?: InputMaybe<Scalars["String"]["input"]>;
  error_hash?: InputMaybe<Scalars["String"]["input"]>;
  error_pattern?: InputMaybe<Scalars["String"]["input"]>;
  error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  frequency_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  github_repo?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_new_pattern?: InputMaybe<Scalars["Boolean"]["input"]>;
  message?: InputMaybe<Scalars["String"]["input"]>;
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  related_errors?: InputMaybe<Scalars["jsonb"]["input"]>;
  request_id?: InputMaybe<Scalars["uuid"]["input"]>;
  service_name?: InputMaybe<Scalars["String"]["input"]>;
  severity?: InputMaybe<Scalars["error_severity"]["input"]>;
  stack_trace?: InputMaybe<Scalars["String"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate max on columns */
export type ErrorLogsMaxFields = {
  __typename?: "error_logs_max_fields";
  correlation_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  domain?: Maybe<Scalars["String"]["output"]>;
  environment?: Maybe<Scalars["String"]["output"]>;
  error_hash?: Maybe<Scalars["String"]["output"]>;
  error_pattern?: Maybe<Scalars["String"]["output"]>;
  error_type?: Maybe<Scalars["error_type"]["output"]>;
  github_repo?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  message?: Maybe<Scalars["String"]["output"]>;
  request_id?: Maybe<Scalars["uuid"]["output"]>;
  service_name?: Maybe<Scalars["String"]["output"]>;
  severity?: Maybe<Scalars["error_severity"]["output"]>;
  stack_trace?: Maybe<Scalars["String"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** aggregate min on columns */
export type ErrorLogsMinFields = {
  __typename?: "error_logs_min_fields";
  correlation_id?: Maybe<Scalars["uuid"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  domain?: Maybe<Scalars["String"]["output"]>;
  environment?: Maybe<Scalars["String"]["output"]>;
  error_hash?: Maybe<Scalars["String"]["output"]>;
  error_pattern?: Maybe<Scalars["String"]["output"]>;
  error_type?: Maybe<Scalars["error_type"]["output"]>;
  github_repo?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  message?: Maybe<Scalars["String"]["output"]>;
  request_id?: Maybe<Scalars["uuid"]["output"]>;
  service_name?: Maybe<Scalars["String"]["output"]>;
  severity?: Maybe<Scalars["error_severity"]["output"]>;
  stack_trace?: Maybe<Scalars["String"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** response of any mutation on the table "error_logs" */
export type ErrorLogsMutationResponse = {
  __typename?: "error_logs_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<ErrorLogs>;
};

/** on_conflict condition type for table "error_logs" */
export type ErrorLogsOnConflict = {
  constraint: ErrorLogsConstraint;
  update_columns?: Array<ErrorLogsUpdateColumn>;
  where?: InputMaybe<ErrorLogsBoolExp>;
};

/** Ordering options when selecting data from "error_logs". */
export type ErrorLogsOrderBy = {
  context?: InputMaybe<OrderBy>;
  correlation_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  domain?: InputMaybe<OrderBy>;
  environment?: InputMaybe<OrderBy>;
  error_hash?: InputMaybe<OrderBy>;
  error_pattern?: InputMaybe<OrderBy>;
  error_type?: InputMaybe<OrderBy>;
  frequency_data?: InputMaybe<OrderBy>;
  github_repo?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  is_new_pattern?: InputMaybe<OrderBy>;
  message?: InputMaybe<OrderBy>;
  metadata?: InputMaybe<OrderBy>;
  related_errors?: InputMaybe<OrderBy>;
  request_id?: InputMaybe<OrderBy>;
  service_name?: InputMaybe<OrderBy>;
  severity?: InputMaybe<OrderBy>;
  stack_trace?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: error_logs */
export type ErrorLogsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type ErrorLogsPrependInput = {
  context?: InputMaybe<Scalars["jsonb"]["input"]>;
  frequency_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  related_errors?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "error_logs" */
export enum ErrorLogsSelectColumn {
  /** column name */
  CONTEXT = "context",
  /** column name */
  CORRELATION_ID = "correlation_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DOMAIN = "domain",
  /** column name */
  ENVIRONMENT = "environment",
  /** column name */
  ERROR_HASH = "error_hash",
  /** column name */
  ERROR_PATTERN = "error_pattern",
  /** column name */
  ERROR_TYPE = "error_type",
  /** column name */
  FREQUENCY_DATA = "frequency_data",
  /** column name */
  GITHUB_REPO = "github_repo",
  /** column name */
  ID = "id",
  /** column name */
  IS_NEW_PATTERN = "is_new_pattern",
  /** column name */
  MESSAGE = "message",
  /** column name */
  METADATA = "metadata",
  /** column name */
  RELATED_ERRORS = "related_errors",
  /** column name */
  REQUEST_ID = "request_id",
  /** column name */
  SERVICE_NAME = "service_name",
  /** column name */
  SEVERITY = "severity",
  /** column name */
  STACK_TRACE = "stack_trace",
  /** column name */
  USER_ID = "user_id",
}

/** input type for updating data in table "error_logs" */
export type ErrorLogsSetInput = {
  context?: InputMaybe<Scalars["jsonb"]["input"]>;
  correlation_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  domain?: InputMaybe<Scalars["String"]["input"]>;
  environment?: InputMaybe<Scalars["String"]["input"]>;
  error_hash?: InputMaybe<Scalars["String"]["input"]>;
  error_pattern?: InputMaybe<Scalars["String"]["input"]>;
  error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  frequency_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  github_repo?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_new_pattern?: InputMaybe<Scalars["Boolean"]["input"]>;
  message?: InputMaybe<Scalars["String"]["input"]>;
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  related_errors?: InputMaybe<Scalars["jsonb"]["input"]>;
  request_id?: InputMaybe<Scalars["uuid"]["input"]>;
  service_name?: InputMaybe<Scalars["String"]["input"]>;
  severity?: InputMaybe<Scalars["error_severity"]["input"]>;
  stack_trace?: InputMaybe<Scalars["String"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** Streaming cursor of the table "error_logs" */
export type ErrorLogsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ErrorLogsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ErrorLogsStreamCursorValueInput = {
  context?: InputMaybe<Scalars["jsonb"]["input"]>;
  correlation_id?: InputMaybe<Scalars["uuid"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  domain?: InputMaybe<Scalars["String"]["input"]>;
  environment?: InputMaybe<Scalars["String"]["input"]>;
  error_hash?: InputMaybe<Scalars["String"]["input"]>;
  error_pattern?: InputMaybe<Scalars["String"]["input"]>;
  error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  frequency_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  github_repo?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_new_pattern?: InputMaybe<Scalars["Boolean"]["input"]>;
  message?: InputMaybe<Scalars["String"]["input"]>;
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  related_errors?: InputMaybe<Scalars["jsonb"]["input"]>;
  request_id?: InputMaybe<Scalars["uuid"]["input"]>;
  service_name?: InputMaybe<Scalars["String"]["input"]>;
  severity?: InputMaybe<Scalars["error_severity"]["input"]>;
  stack_trace?: InputMaybe<Scalars["String"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** update columns of table "error_logs" */
export enum ErrorLogsUpdateColumn {
  /** column name */
  CONTEXT = "context",
  /** column name */
  CORRELATION_ID = "correlation_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DOMAIN = "domain",
  /** column name */
  ENVIRONMENT = "environment",
  /** column name */
  ERROR_HASH = "error_hash",
  /** column name */
  ERROR_PATTERN = "error_pattern",
  /** column name */
  ERROR_TYPE = "error_type",
  /** column name */
  FREQUENCY_DATA = "frequency_data",
  /** column name */
  GITHUB_REPO = "github_repo",
  /** column name */
  ID = "id",
  /** column name */
  IS_NEW_PATTERN = "is_new_pattern",
  /** column name */
  MESSAGE = "message",
  /** column name */
  METADATA = "metadata",
  /** column name */
  RELATED_ERRORS = "related_errors",
  /** column name */
  REQUEST_ID = "request_id",
  /** column name */
  SERVICE_NAME = "service_name",
  /** column name */
  SEVERITY = "severity",
  /** column name */
  STACK_TRACE = "stack_trace",
  /** column name */
  USER_ID = "user_id",
}

export type ErrorLogsUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<ErrorLogsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<ErrorLogsDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<ErrorLogsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<ErrorLogsDeleteKeyInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<ErrorLogsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<ErrorLogsSetInput>;
  /** filter the rows which have to be updated */
  where: ErrorLogsBoolExp;
};

/** columns and relationships of "error_metrics" */
export type ErrorMetrics = {
  __typename?: "error_metrics";
  error_count?: Maybe<Scalars["bigint"]["output"]>;
  error_type?: Maybe<Scalars["error_type"]["output"]>;
  service_name?: Maybe<Scalars["String"]["output"]>;
  severity?: Maybe<Scalars["error_severity"]["output"]>;
  time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregated selection of "error_metrics" */
export type ErrorMetricsAggregate = {
  __typename?: "error_metrics_aggregate";
  aggregate?: Maybe<ErrorMetricsAggregateFields>;
  nodes: Array<ErrorMetrics>;
};

/** aggregate fields of "error_metrics" */
export type ErrorMetricsAggregateFields = {
  __typename?: "error_metrics_aggregate_fields";
  avg?: Maybe<ErrorMetricsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ErrorMetricsMaxFields>;
  min?: Maybe<ErrorMetricsMinFields>;
  stddev?: Maybe<ErrorMetricsStddevFields>;
  stddev_pop?: Maybe<ErrorMetricsStddevPopFields>;
  stddev_samp?: Maybe<ErrorMetricsStddevSampFields>;
  sum?: Maybe<ErrorMetricsSumFields>;
  var_pop?: Maybe<ErrorMetricsVarPopFields>;
  var_samp?: Maybe<ErrorMetricsVarSampFields>;
  variance?: Maybe<ErrorMetricsVarianceFields>;
};

/** aggregate fields of "error_metrics" */
export type ErrorMetricsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ErrorMetricsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type ErrorMetricsAvgFields = {
  __typename?: "error_metrics_avg_fields";
  error_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "error_metrics". All fields are combined with a logical 'AND'. */
export type ErrorMetricsBoolExp = {
  _and?: InputMaybe<Array<ErrorMetricsBoolExp>>;
  _not?: InputMaybe<ErrorMetricsBoolExp>;
  _or?: InputMaybe<Array<ErrorMetricsBoolExp>>;
  error_count?: InputMaybe<BigintComparisonExp>;
  error_type?: InputMaybe<ErrorTypeComparisonExp>;
  service_name?: InputMaybe<StringComparisonExp>;
  severity?: InputMaybe<ErrorSeverityComparisonExp>;
  time_bucket?: InputMaybe<TimestamptzComparisonExp>;
};

/** aggregate max on columns */
export type ErrorMetricsMaxFields = {
  __typename?: "error_metrics_max_fields";
  error_count?: Maybe<Scalars["bigint"]["output"]>;
  error_type?: Maybe<Scalars["error_type"]["output"]>;
  service_name?: Maybe<Scalars["String"]["output"]>;
  severity?: Maybe<Scalars["error_severity"]["output"]>;
  time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregate min on columns */
export type ErrorMetricsMinFields = {
  __typename?: "error_metrics_min_fields";
  error_count?: Maybe<Scalars["bigint"]["output"]>;
  error_type?: Maybe<Scalars["error_type"]["output"]>;
  service_name?: Maybe<Scalars["String"]["output"]>;
  severity?: Maybe<Scalars["error_severity"]["output"]>;
  time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** Ordering options when selecting data from "error_metrics". */
export type ErrorMetricsOrderBy = {
  error_count?: InputMaybe<OrderBy>;
  error_type?: InputMaybe<OrderBy>;
  service_name?: InputMaybe<OrderBy>;
  severity?: InputMaybe<OrderBy>;
  time_bucket?: InputMaybe<OrderBy>;
};

/** select columns of table "error_metrics" */
export enum ErrorMetricsSelectColumn {
  /** column name */
  ERROR_COUNT = "error_count",
  /** column name */
  ERROR_TYPE = "error_type",
  /** column name */
  SERVICE_NAME = "service_name",
  /** column name */
  SEVERITY = "severity",
  /** column name */
  TIME_BUCKET = "time_bucket",
}

/** aggregate stddev on columns */
export type ErrorMetricsStddevFields = {
  __typename?: "error_metrics_stddev_fields";
  error_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type ErrorMetricsStddevPopFields = {
  __typename?: "error_metrics_stddev_pop_fields";
  error_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type ErrorMetricsStddevSampFields = {
  __typename?: "error_metrics_stddev_samp_fields";
  error_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "error_metrics" */
export type ErrorMetricsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ErrorMetricsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ErrorMetricsStreamCursorValueInput = {
  error_count?: InputMaybe<Scalars["bigint"]["input"]>;
  error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  service_name?: InputMaybe<Scalars["String"]["input"]>;
  severity?: InputMaybe<Scalars["error_severity"]["input"]>;
  time_bucket?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate sum on columns */
export type ErrorMetricsSumFields = {
  __typename?: "error_metrics_sum_fields";
  error_count?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate var_pop on columns */
export type ErrorMetricsVarPopFields = {
  __typename?: "error_metrics_var_pop_fields";
  error_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type ErrorMetricsVarSampFields = {
  __typename?: "error_metrics_var_samp_fields";
  error_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type ErrorMetricsVarianceFields = {
  __typename?: "error_metrics_variance_fields";
  error_count?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "error_patterns" */
export type ErrorPatterns = {
  __typename?: "error_patterns";
  contexts?: Maybe<Scalars["jsonb"]["output"]>;
  daily_frequency?: Maybe<Scalars["float8"]["output"]>;
  days_active?: Maybe<Scalars["bigint"]["output"]>;
  error_hash?: Maybe<Scalars["String"]["output"]>;
  error_pattern?: Maybe<Scalars["String"]["output"]>;
  first_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  is_new?: Maybe<Scalars["Boolean"]["output"]>;
  last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
  service_name?: Maybe<Scalars["String"]["output"]>;
  severity_levels?: Maybe<Array<Scalars["error_severity"]["output"]>>;
};

/** columns and relationships of "error_patterns" */
export type ErrorPatternsContextsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "error_patterns" */
export type ErrorPatternsAggregate = {
  __typename?: "error_patterns_aggregate";
  aggregate?: Maybe<ErrorPatternsAggregateFields>;
  nodes: Array<ErrorPatterns>;
};

/** aggregate fields of "error_patterns" */
export type ErrorPatternsAggregateFields = {
  __typename?: "error_patterns_aggregate_fields";
  avg?: Maybe<ErrorPatternsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ErrorPatternsMaxFields>;
  min?: Maybe<ErrorPatternsMinFields>;
  stddev?: Maybe<ErrorPatternsStddevFields>;
  stddev_pop?: Maybe<ErrorPatternsStddevPopFields>;
  stddev_samp?: Maybe<ErrorPatternsStddevSampFields>;
  sum?: Maybe<ErrorPatternsSumFields>;
  var_pop?: Maybe<ErrorPatternsVarPopFields>;
  var_samp?: Maybe<ErrorPatternsVarSampFields>;
  variance?: Maybe<ErrorPatternsVarianceFields>;
};

/** aggregate fields of "error_patterns" */
export type ErrorPatternsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ErrorPatternsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type ErrorPatternsAvgFields = {
  __typename?: "error_patterns_avg_fields";
  daily_frequency?: Maybe<Scalars["Float"]["output"]>;
  days_active?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  occurrence_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "error_patterns". All fields are combined with a logical 'AND'. */
export type ErrorPatternsBoolExp = {
  _and?: InputMaybe<Array<ErrorPatternsBoolExp>>;
  _not?: InputMaybe<ErrorPatternsBoolExp>;
  _or?: InputMaybe<Array<ErrorPatternsBoolExp>>;
  contexts?: InputMaybe<JsonbComparisonExp>;
  daily_frequency?: InputMaybe<Float8ComparisonExp>;
  days_active?: InputMaybe<BigintComparisonExp>;
  error_hash?: InputMaybe<StringComparisonExp>;
  error_pattern?: InputMaybe<StringComparisonExp>;
  first_seen?: InputMaybe<TimestamptzComparisonExp>;
  id?: InputMaybe<BigintComparisonExp>;
  is_new?: InputMaybe<BooleanComparisonExp>;
  last_seen?: InputMaybe<TimestamptzComparisonExp>;
  occurrence_count?: InputMaybe<BigintComparisonExp>;
  service_name?: InputMaybe<StringComparisonExp>;
  severity_levels?: InputMaybe<ErrorSeverityArrayComparisonExp>;
};

/** aggregate max on columns */
export type ErrorPatternsMaxFields = {
  __typename?: "error_patterns_max_fields";
  daily_frequency?: Maybe<Scalars["float8"]["output"]>;
  days_active?: Maybe<Scalars["bigint"]["output"]>;
  error_hash?: Maybe<Scalars["String"]["output"]>;
  error_pattern?: Maybe<Scalars["String"]["output"]>;
  first_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
  service_name?: Maybe<Scalars["String"]["output"]>;
  severity_levels?: Maybe<Array<Scalars["error_severity"]["output"]>>;
};

/** aggregate min on columns */
export type ErrorPatternsMinFields = {
  __typename?: "error_patterns_min_fields";
  daily_frequency?: Maybe<Scalars["float8"]["output"]>;
  days_active?: Maybe<Scalars["bigint"]["output"]>;
  error_hash?: Maybe<Scalars["String"]["output"]>;
  error_pattern?: Maybe<Scalars["String"]["output"]>;
  first_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
  service_name?: Maybe<Scalars["String"]["output"]>;
  severity_levels?: Maybe<Array<Scalars["error_severity"]["output"]>>;
};

/** Ordering options when selecting data from "error_patterns". */
export type ErrorPatternsOrderBy = {
  contexts?: InputMaybe<OrderBy>;
  daily_frequency?: InputMaybe<OrderBy>;
  days_active?: InputMaybe<OrderBy>;
  error_hash?: InputMaybe<OrderBy>;
  error_pattern?: InputMaybe<OrderBy>;
  first_seen?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  is_new?: InputMaybe<OrderBy>;
  last_seen?: InputMaybe<OrderBy>;
  occurrence_count?: InputMaybe<OrderBy>;
  service_name?: InputMaybe<OrderBy>;
  severity_levels?: InputMaybe<OrderBy>;
};

/** select columns of table "error_patterns" */
export enum ErrorPatternsSelectColumn {
  /** column name */
  CONTEXTS = "contexts",
  /** column name */
  DAILY_FREQUENCY = "daily_frequency",
  /** column name */
  DAYS_ACTIVE = "days_active",
  /** column name */
  ERROR_HASH = "error_hash",
  /** column name */
  ERROR_PATTERN = "error_pattern",
  /** column name */
  FIRST_SEEN = "first_seen",
  /** column name */
  ID = "id",
  /** column name */
  IS_NEW = "is_new",
  /** column name */
  LAST_SEEN = "last_seen",
  /** column name */
  OCCURRENCE_COUNT = "occurrence_count",
  /** column name */
  SERVICE_NAME = "service_name",
  /** column name */
  SEVERITY_LEVELS = "severity_levels",
}

/** aggregate stddev on columns */
export type ErrorPatternsStddevFields = {
  __typename?: "error_patterns_stddev_fields";
  daily_frequency?: Maybe<Scalars["Float"]["output"]>;
  days_active?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  occurrence_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type ErrorPatternsStddevPopFields = {
  __typename?: "error_patterns_stddev_pop_fields";
  daily_frequency?: Maybe<Scalars["Float"]["output"]>;
  days_active?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  occurrence_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type ErrorPatternsStddevSampFields = {
  __typename?: "error_patterns_stddev_samp_fields";
  daily_frequency?: Maybe<Scalars["Float"]["output"]>;
  days_active?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  occurrence_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "error_patterns" */
export type ErrorPatternsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ErrorPatternsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ErrorPatternsStreamCursorValueInput = {
  contexts?: InputMaybe<Scalars["jsonb"]["input"]>;
  daily_frequency?: InputMaybe<Scalars["float8"]["input"]>;
  days_active?: InputMaybe<Scalars["bigint"]["input"]>;
  error_hash?: InputMaybe<Scalars["String"]["input"]>;
  error_pattern?: InputMaybe<Scalars["String"]["input"]>;
  first_seen?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  is_new?: InputMaybe<Scalars["Boolean"]["input"]>;
  last_seen?: InputMaybe<Scalars["timestamptz"]["input"]>;
  occurrence_count?: InputMaybe<Scalars["bigint"]["input"]>;
  service_name?: InputMaybe<Scalars["String"]["input"]>;
  severity_levels?: InputMaybe<Array<Scalars["error_severity"]["input"]>>;
};

/** aggregate sum on columns */
export type ErrorPatternsSumFields = {
  __typename?: "error_patterns_sum_fields";
  daily_frequency?: Maybe<Scalars["float8"]["output"]>;
  days_active?: Maybe<Scalars["bigint"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate var_pop on columns */
export type ErrorPatternsVarPopFields = {
  __typename?: "error_patterns_var_pop_fields";
  daily_frequency?: Maybe<Scalars["Float"]["output"]>;
  days_active?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  occurrence_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type ErrorPatternsVarSampFields = {
  __typename?: "error_patterns_var_samp_fields";
  daily_frequency?: Maybe<Scalars["Float"]["output"]>;
  days_active?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  occurrence_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type ErrorPatternsVarianceFields = {
  __typename?: "error_patterns_variance_fields";
  daily_frequency?: Maybe<Scalars["Float"]["output"]>;
  days_active?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  occurrence_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to compare columns of type "error_severity". All fields are combined with logical 'AND'. */
export type ErrorSeverityArrayComparisonExp = {
  /** is the array contained in the given array value */
  _contained_in?: InputMaybe<Array<Scalars["error_severity"]["input"]>>;
  /** does the array contain the given value */
  _contains?: InputMaybe<Array<Scalars["error_severity"]["input"]>>;
  _eq?: InputMaybe<Array<Scalars["error_severity"]["input"]>>;
  _gt?: InputMaybe<Array<Scalars["error_severity"]["input"]>>;
  _gte?: InputMaybe<Array<Scalars["error_severity"]["input"]>>;
  _in?: InputMaybe<Array<Array<Scalars["error_severity"]["input"]>>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Array<Scalars["error_severity"]["input"]>>;
  _lte?: InputMaybe<Array<Scalars["error_severity"]["input"]>>;
  _neq?: InputMaybe<Array<Scalars["error_severity"]["input"]>>;
  _nin?: InputMaybe<Array<Array<Scalars["error_severity"]["input"]>>>;
};

/** Boolean expression to compare columns of type "error_severity". All fields are combined with logical 'AND'. */
export type ErrorSeverityComparisonExp = {
  _eq?: InputMaybe<Scalars["error_severity"]["input"]>;
  _gt?: InputMaybe<Scalars["error_severity"]["input"]>;
  _gte?: InputMaybe<Scalars["error_severity"]["input"]>;
  _in?: InputMaybe<Array<Scalars["error_severity"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["error_severity"]["input"]>;
  _lte?: InputMaybe<Scalars["error_severity"]["input"]>;
  _neq?: InputMaybe<Scalars["error_severity"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["error_severity"]["input"]>>;
};

/** columns and relationships of "error_stats" */
export type ErrorStats = {
  __typename?: "error_stats";
  calls?: Maybe<Scalars["bigint"]["output"]>;
  max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  mean_exec_time?: Maybe<Scalars["float8"]["output"]>;
  query?: Maybe<Scalars["String"]["output"]>;
  queryid?: Maybe<Scalars["bigint"]["output"]>;
  rows?: Maybe<Scalars["bigint"]["output"]>;
  toplevel?: Maybe<Scalars["Boolean"]["output"]>;
};

/** aggregated selection of "error_stats" */
export type ErrorStatsAggregate = {
  __typename?: "error_stats_aggregate";
  aggregate?: Maybe<ErrorStatsAggregateFields>;
  nodes: Array<ErrorStats>;
};

/** aggregate fields of "error_stats" */
export type ErrorStatsAggregateFields = {
  __typename?: "error_stats_aggregate_fields";
  avg?: Maybe<ErrorStatsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ErrorStatsMaxFields>;
  min?: Maybe<ErrorStatsMinFields>;
  stddev?: Maybe<ErrorStatsStddevFields>;
  stddev_pop?: Maybe<ErrorStatsStddevPopFields>;
  stddev_samp?: Maybe<ErrorStatsStddevSampFields>;
  sum?: Maybe<ErrorStatsSumFields>;
  var_pop?: Maybe<ErrorStatsVarPopFields>;
  var_samp?: Maybe<ErrorStatsVarSampFields>;
  variance?: Maybe<ErrorStatsVarianceFields>;
};

/** aggregate fields of "error_stats" */
export type ErrorStatsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ErrorStatsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type ErrorStatsAvgFields = {
  __typename?: "error_stats_avg_fields";
  calls?: Maybe<Scalars["Float"]["output"]>;
  max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  mean_exec_time?: Maybe<Scalars["Float"]["output"]>;
  queryid?: Maybe<Scalars["Float"]["output"]>;
  rows?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "error_stats". All fields are combined with a logical 'AND'. */
export type ErrorStatsBoolExp = {
  _and?: InputMaybe<Array<ErrorStatsBoolExp>>;
  _not?: InputMaybe<ErrorStatsBoolExp>;
  _or?: InputMaybe<Array<ErrorStatsBoolExp>>;
  calls?: InputMaybe<BigintComparisonExp>;
  max_exec_time?: InputMaybe<Float8ComparisonExp>;
  mean_exec_time?: InputMaybe<Float8ComparisonExp>;
  query?: InputMaybe<StringComparisonExp>;
  queryid?: InputMaybe<BigintComparisonExp>;
  rows?: InputMaybe<BigintComparisonExp>;
  toplevel?: InputMaybe<BooleanComparisonExp>;
};

/** aggregate max on columns */
export type ErrorStatsMaxFields = {
  __typename?: "error_stats_max_fields";
  calls?: Maybe<Scalars["bigint"]["output"]>;
  max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  mean_exec_time?: Maybe<Scalars["float8"]["output"]>;
  query?: Maybe<Scalars["String"]["output"]>;
  queryid?: Maybe<Scalars["bigint"]["output"]>;
  rows?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate min on columns */
export type ErrorStatsMinFields = {
  __typename?: "error_stats_min_fields";
  calls?: Maybe<Scalars["bigint"]["output"]>;
  max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  mean_exec_time?: Maybe<Scalars["float8"]["output"]>;
  query?: Maybe<Scalars["String"]["output"]>;
  queryid?: Maybe<Scalars["bigint"]["output"]>;
  rows?: Maybe<Scalars["bigint"]["output"]>;
};

/** Ordering options when selecting data from "error_stats". */
export type ErrorStatsOrderBy = {
  calls?: InputMaybe<OrderBy>;
  max_exec_time?: InputMaybe<OrderBy>;
  mean_exec_time?: InputMaybe<OrderBy>;
  query?: InputMaybe<OrderBy>;
  queryid?: InputMaybe<OrderBy>;
  rows?: InputMaybe<OrderBy>;
  toplevel?: InputMaybe<OrderBy>;
};

/** select columns of table "error_stats" */
export enum ErrorStatsSelectColumn {
  /** column name */
  CALLS = "calls",
  /** column name */
  MAX_EXEC_TIME = "max_exec_time",
  /** column name */
  MEAN_EXEC_TIME = "mean_exec_time",
  /** column name */
  QUERY = "query",
  /** column name */
  QUERYID = "queryid",
  /** column name */
  ROWS = "rows",
  /** column name */
  TOPLEVEL = "toplevel",
}

/** aggregate stddev on columns */
export type ErrorStatsStddevFields = {
  __typename?: "error_stats_stddev_fields";
  calls?: Maybe<Scalars["Float"]["output"]>;
  max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  mean_exec_time?: Maybe<Scalars["Float"]["output"]>;
  queryid?: Maybe<Scalars["Float"]["output"]>;
  rows?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type ErrorStatsStddevPopFields = {
  __typename?: "error_stats_stddev_pop_fields";
  calls?: Maybe<Scalars["Float"]["output"]>;
  max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  mean_exec_time?: Maybe<Scalars["Float"]["output"]>;
  queryid?: Maybe<Scalars["Float"]["output"]>;
  rows?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type ErrorStatsStddevSampFields = {
  __typename?: "error_stats_stddev_samp_fields";
  calls?: Maybe<Scalars["Float"]["output"]>;
  max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  mean_exec_time?: Maybe<Scalars["Float"]["output"]>;
  queryid?: Maybe<Scalars["Float"]["output"]>;
  rows?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "error_stats" */
export type ErrorStatsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ErrorStatsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ErrorStatsStreamCursorValueInput = {
  calls?: InputMaybe<Scalars["bigint"]["input"]>;
  max_exec_time?: InputMaybe<Scalars["float8"]["input"]>;
  mean_exec_time?: InputMaybe<Scalars["float8"]["input"]>;
  query?: InputMaybe<Scalars["String"]["input"]>;
  queryid?: InputMaybe<Scalars["bigint"]["input"]>;
  rows?: InputMaybe<Scalars["bigint"]["input"]>;
  toplevel?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate sum on columns */
export type ErrorStatsSumFields = {
  __typename?: "error_stats_sum_fields";
  calls?: Maybe<Scalars["bigint"]["output"]>;
  max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  mean_exec_time?: Maybe<Scalars["float8"]["output"]>;
  queryid?: Maybe<Scalars["bigint"]["output"]>;
  rows?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate var_pop on columns */
export type ErrorStatsVarPopFields = {
  __typename?: "error_stats_var_pop_fields";
  calls?: Maybe<Scalars["Float"]["output"]>;
  max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  mean_exec_time?: Maybe<Scalars["Float"]["output"]>;
  queryid?: Maybe<Scalars["Float"]["output"]>;
  rows?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type ErrorStatsVarSampFields = {
  __typename?: "error_stats_var_samp_fields";
  calls?: Maybe<Scalars["Float"]["output"]>;
  max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  mean_exec_time?: Maybe<Scalars["Float"]["output"]>;
  queryid?: Maybe<Scalars["Float"]["output"]>;
  rows?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type ErrorStatsVarianceFields = {
  __typename?: "error_stats_variance_fields";
  calls?: Maybe<Scalars["Float"]["output"]>;
  max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  mean_exec_time?: Maybe<Scalars["Float"]["output"]>;
  queryid?: Maybe<Scalars["Float"]["output"]>;
  rows?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to compare columns of type "error_type". All fields are combined with logical 'AND'. */
export type ErrorTypeComparisonExp = {
  _eq?: InputMaybe<Scalars["error_type"]["input"]>;
  _gt?: InputMaybe<Scalars["error_type"]["input"]>;
  _gte?: InputMaybe<Scalars["error_type"]["input"]>;
  _in?: InputMaybe<Array<Scalars["error_type"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["error_type"]["input"]>;
  _lte?: InputMaybe<Scalars["error_type"]["input"]>;
  _neq?: InputMaybe<Scalars["error_type"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["error_type"]["input"]>>;
};

/** columns and relationships of "feature_requests" */
export type FeatureRequests = {
  __typename?: "feature_requests";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  downvotes?: Maybe<Scalars["Int"]["output"]>;
  engagement_score?: Maybe<Scalars["Int"]["output"]>;
  /** An array relationship */
  feature_votes: Array<FeatureVotes>;
  /** An aggregate relationship */
  feature_votes_aggregate: FeatureVotesAggregate;
  id: Scalars["uuid"]["output"];
  priority_score?: Maybe<Scalars["Int"]["output"]>;
  status: Scalars["String"]["output"];
  title: Scalars["String"]["output"];
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  upvotes?: Maybe<Scalars["Int"]["output"]>;
};

/** columns and relationships of "feature_requests" */
export type FeatureRequestsFeatureVotesArgs = {
  distinct_on?: InputMaybe<Array<FeatureVotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeatureVotesOrderBy>>;
  where?: InputMaybe<FeatureVotesBoolExp>;
};

/** columns and relationships of "feature_requests" */
export type FeatureRequestsFeatureVotesAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeatureVotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeatureVotesOrderBy>>;
  where?: InputMaybe<FeatureVotesBoolExp>;
};

/** aggregated selection of "feature_requests" */
export type FeatureRequestsAggregate = {
  __typename?: "feature_requests_aggregate";
  aggregate?: Maybe<FeatureRequestsAggregateFields>;
  nodes: Array<FeatureRequests>;
};

/** aggregate fields of "feature_requests" */
export type FeatureRequestsAggregateFields = {
  __typename?: "feature_requests_aggregate_fields";
  avg?: Maybe<FeatureRequestsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<FeatureRequestsMaxFields>;
  min?: Maybe<FeatureRequestsMinFields>;
  stddev?: Maybe<FeatureRequestsStddevFields>;
  stddev_pop?: Maybe<FeatureRequestsStddevPopFields>;
  stddev_samp?: Maybe<FeatureRequestsStddevSampFields>;
  sum?: Maybe<FeatureRequestsSumFields>;
  var_pop?: Maybe<FeatureRequestsVarPopFields>;
  var_samp?: Maybe<FeatureRequestsVarSampFields>;
  variance?: Maybe<FeatureRequestsVarianceFields>;
};

/** aggregate fields of "feature_requests" */
export type FeatureRequestsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<FeatureRequestsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type FeatureRequestsAvgFields = {
  __typename?: "feature_requests_avg_fields";
  downvotes?: Maybe<Scalars["Float"]["output"]>;
  engagement_score?: Maybe<Scalars["Float"]["output"]>;
  priority_score?: Maybe<Scalars["Float"]["output"]>;
  upvotes?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "feature_requests". All fields are combined with a logical 'AND'. */
export type FeatureRequestsBoolExp = {
  _and?: InputMaybe<Array<FeatureRequestsBoolExp>>;
  _not?: InputMaybe<FeatureRequestsBoolExp>;
  _or?: InputMaybe<Array<FeatureRequestsBoolExp>>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  description?: InputMaybe<StringComparisonExp>;
  downvotes?: InputMaybe<IntComparisonExp>;
  engagement_score?: InputMaybe<IntComparisonExp>;
  feature_votes?: InputMaybe<FeatureVotesBoolExp>;
  feature_votes_aggregate?: InputMaybe<FeatureVotesAggregateBoolExp>;
  id?: InputMaybe<UuidComparisonExp>;
  priority_score?: InputMaybe<IntComparisonExp>;
  status?: InputMaybe<StringComparisonExp>;
  title?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  upvotes?: InputMaybe<IntComparisonExp>;
};

/** unique or primary key constraints on table "feature_requests" */
export enum FeatureRequestsConstraint {
  /** unique or primary key constraint on columns "id" */
  FEATURE_REQUESTS_PKEY = "feature_requests_pkey",
}

/** input type for incrementing numeric columns in table "feature_requests" */
export type FeatureRequestsIncInput = {
  downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  engagement_score?: InputMaybe<Scalars["Int"]["input"]>;
  priority_score?: InputMaybe<Scalars["Int"]["input"]>;
  upvotes?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "feature_requests" */
export type FeatureRequestsInsertInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  engagement_score?: InputMaybe<Scalars["Int"]["input"]>;
  feature_votes?: InputMaybe<FeatureVotesArrRelInsertInput>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  priority_score?: InputMaybe<Scalars["Int"]["input"]>;
  status?: InputMaybe<Scalars["String"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  upvotes?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate max on columns */
export type FeatureRequestsMaxFields = {
  __typename?: "feature_requests_max_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  downvotes?: Maybe<Scalars["Int"]["output"]>;
  engagement_score?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  priority_score?: Maybe<Scalars["Int"]["output"]>;
  status?: Maybe<Scalars["String"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  upvotes?: Maybe<Scalars["Int"]["output"]>;
};

/** aggregate min on columns */
export type FeatureRequestsMinFields = {
  __typename?: "feature_requests_min_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  downvotes?: Maybe<Scalars["Int"]["output"]>;
  engagement_score?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  priority_score?: Maybe<Scalars["Int"]["output"]>;
  status?: Maybe<Scalars["String"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  upvotes?: Maybe<Scalars["Int"]["output"]>;
};

/** response of any mutation on the table "feature_requests" */
export type FeatureRequestsMutationResponse = {
  __typename?: "feature_requests_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<FeatureRequests>;
};

/** input type for inserting object relation for remote table "feature_requests" */
export type FeatureRequestsObjRelInsertInput = {
  data: FeatureRequestsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<FeatureRequestsOnConflict>;
};

/** on_conflict condition type for table "feature_requests" */
export type FeatureRequestsOnConflict = {
  constraint: FeatureRequestsConstraint;
  update_columns?: Array<FeatureRequestsUpdateColumn>;
  where?: InputMaybe<FeatureRequestsBoolExp>;
};

/** Ordering options when selecting data from "feature_requests". */
export type FeatureRequestsOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  description?: InputMaybe<OrderBy>;
  downvotes?: InputMaybe<OrderBy>;
  engagement_score?: InputMaybe<OrderBy>;
  feature_votes_aggregate?: InputMaybe<FeatureVotesAggregateOrderBy>;
  id?: InputMaybe<OrderBy>;
  priority_score?: InputMaybe<OrderBy>;
  status?: InputMaybe<OrderBy>;
  title?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  upvotes?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: feature_requests */
export type FeatureRequestsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "feature_requests" */
export enum FeatureRequestsSelectColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  DOWNVOTES = "downvotes",
  /** column name */
  ENGAGEMENT_SCORE = "engagement_score",
  /** column name */
  ID = "id",
  /** column name */
  PRIORITY_SCORE = "priority_score",
  /** column name */
  STATUS = "status",
  /** column name */
  TITLE = "title",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  UPVOTES = "upvotes",
}

/** input type for updating data in table "feature_requests" */
export type FeatureRequestsSetInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  engagement_score?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  priority_score?: InputMaybe<Scalars["Int"]["input"]>;
  status?: InputMaybe<Scalars["String"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  upvotes?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate stddev on columns */
export type FeatureRequestsStddevFields = {
  __typename?: "feature_requests_stddev_fields";
  downvotes?: Maybe<Scalars["Float"]["output"]>;
  engagement_score?: Maybe<Scalars["Float"]["output"]>;
  priority_score?: Maybe<Scalars["Float"]["output"]>;
  upvotes?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type FeatureRequestsStddevPopFields = {
  __typename?: "feature_requests_stddev_pop_fields";
  downvotes?: Maybe<Scalars["Float"]["output"]>;
  engagement_score?: Maybe<Scalars["Float"]["output"]>;
  priority_score?: Maybe<Scalars["Float"]["output"]>;
  upvotes?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type FeatureRequestsStddevSampFields = {
  __typename?: "feature_requests_stddev_samp_fields";
  downvotes?: Maybe<Scalars["Float"]["output"]>;
  engagement_score?: Maybe<Scalars["Float"]["output"]>;
  priority_score?: Maybe<Scalars["Float"]["output"]>;
  upvotes?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "feature_requests" */
export type FeatureRequestsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: FeatureRequestsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type FeatureRequestsStreamCursorValueInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  engagement_score?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  priority_score?: InputMaybe<Scalars["Int"]["input"]>;
  status?: InputMaybe<Scalars["String"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  upvotes?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate sum on columns */
export type FeatureRequestsSumFields = {
  __typename?: "feature_requests_sum_fields";
  downvotes?: Maybe<Scalars["Int"]["output"]>;
  engagement_score?: Maybe<Scalars["Int"]["output"]>;
  priority_score?: Maybe<Scalars["Int"]["output"]>;
  upvotes?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "feature_requests" */
export enum FeatureRequestsUpdateColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  DOWNVOTES = "downvotes",
  /** column name */
  ENGAGEMENT_SCORE = "engagement_score",
  /** column name */
  ID = "id",
  /** column name */
  PRIORITY_SCORE = "priority_score",
  /** column name */
  STATUS = "status",
  /** column name */
  TITLE = "title",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  UPVOTES = "upvotes",
}

export type FeatureRequestsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<FeatureRequestsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<FeatureRequestsSetInput>;
  /** filter the rows which have to be updated */
  where: FeatureRequestsBoolExp;
};

/** aggregate var_pop on columns */
export type FeatureRequestsVarPopFields = {
  __typename?: "feature_requests_var_pop_fields";
  downvotes?: Maybe<Scalars["Float"]["output"]>;
  engagement_score?: Maybe<Scalars["Float"]["output"]>;
  priority_score?: Maybe<Scalars["Float"]["output"]>;
  upvotes?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type FeatureRequestsVarSampFields = {
  __typename?: "feature_requests_var_samp_fields";
  downvotes?: Maybe<Scalars["Float"]["output"]>;
  engagement_score?: Maybe<Scalars["Float"]["output"]>;
  priority_score?: Maybe<Scalars["Float"]["output"]>;
  upvotes?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type FeatureRequestsVarianceFields = {
  __typename?: "feature_requests_variance_fields";
  downvotes?: Maybe<Scalars["Float"]["output"]>;
  engagement_score?: Maybe<Scalars["Float"]["output"]>;
  priority_score?: Maybe<Scalars["Float"]["output"]>;
  upvotes?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "feature_votes" */
export type FeatureVotes = {
  __typename?: "feature_votes";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  feature_id: Scalars["uuid"]["output"];
  /** An object relationship */
  feature_request: FeatureRequests;
  feedback?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["uuid"]["output"];
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id: Scalars["uuid"]["output"];
  vote_type: Scalars["smallint"]["output"];
};

/** aggregated selection of "feature_votes" */
export type FeatureVotesAggregate = {
  __typename?: "feature_votes_aggregate";
  aggregate?: Maybe<FeatureVotesAggregateFields>;
  nodes: Array<FeatureVotes>;
};

export type FeatureVotesAggregateBoolExp = {
  count?: InputMaybe<FeatureVotesAggregateBoolExpCount>;
};

export type FeatureVotesAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<FeatureVotesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<FeatureVotesBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "feature_votes" */
export type FeatureVotesAggregateFields = {
  __typename?: "feature_votes_aggregate_fields";
  avg?: Maybe<FeatureVotesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<FeatureVotesMaxFields>;
  min?: Maybe<FeatureVotesMinFields>;
  stddev?: Maybe<FeatureVotesStddevFields>;
  stddev_pop?: Maybe<FeatureVotesStddevPopFields>;
  stddev_samp?: Maybe<FeatureVotesStddevSampFields>;
  sum?: Maybe<FeatureVotesSumFields>;
  var_pop?: Maybe<FeatureVotesVarPopFields>;
  var_samp?: Maybe<FeatureVotesVarSampFields>;
  variance?: Maybe<FeatureVotesVarianceFields>;
};

/** aggregate fields of "feature_votes" */
export type FeatureVotesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<FeatureVotesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "feature_votes" */
export type FeatureVotesAggregateOrderBy = {
  avg?: InputMaybe<FeatureVotesAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<FeatureVotesMaxOrderBy>;
  min?: InputMaybe<FeatureVotesMinOrderBy>;
  stddev?: InputMaybe<FeatureVotesStddevOrderBy>;
  stddev_pop?: InputMaybe<FeatureVotesStddevPopOrderBy>;
  stddev_samp?: InputMaybe<FeatureVotesStddevSampOrderBy>;
  sum?: InputMaybe<FeatureVotesSumOrderBy>;
  var_pop?: InputMaybe<FeatureVotesVarPopOrderBy>;
  var_samp?: InputMaybe<FeatureVotesVarSampOrderBy>;
  variance?: InputMaybe<FeatureVotesVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "feature_votes" */
export type FeatureVotesArrRelInsertInput = {
  data: Array<FeatureVotesInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<FeatureVotesOnConflict>;
};

/** aggregate avg on columns */
export type FeatureVotesAvgFields = {
  __typename?: "feature_votes_avg_fields";
  vote_type?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "feature_votes" */
export type FeatureVotesAvgOrderBy = {
  vote_type?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "feature_votes". All fields are combined with a logical 'AND'. */
export type FeatureVotesBoolExp = {
  _and?: InputMaybe<Array<FeatureVotesBoolExp>>;
  _not?: InputMaybe<FeatureVotesBoolExp>;
  _or?: InputMaybe<Array<FeatureVotesBoolExp>>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  feature_id?: InputMaybe<UuidComparisonExp>;
  feature_request?: InputMaybe<FeatureRequestsBoolExp>;
  feedback?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
  vote_type?: InputMaybe<SmallintComparisonExp>;
};

/** unique or primary key constraints on table "feature_votes" */
export enum FeatureVotesConstraint {
  /** unique or primary key constraint on columns "id" */
  FEATURE_VOTES_PKEY = "feature_votes_pkey",
  /** unique or primary key constraint on columns "user_id", "feature_id" */
  FEATURE_VOTES_USER_FEATURE_UNIQUE = "feature_votes_user_feature_unique",
}

/** input type for incrementing numeric columns in table "feature_votes" */
export type FeatureVotesIncInput = {
  vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
};

/** input type for inserting data into table "feature_votes" */
export type FeatureVotesInsertInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  feature_id?: InputMaybe<Scalars["uuid"]["input"]>;
  feature_request?: InputMaybe<FeatureRequestsObjRelInsertInput>;
  feedback?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
};

/** aggregate max on columns */
export type FeatureVotesMaxFields = {
  __typename?: "feature_votes_max_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  feature_id?: Maybe<Scalars["uuid"]["output"]>;
  feedback?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
  vote_type?: Maybe<Scalars["smallint"]["output"]>;
};

/** order by max() on columns of table "feature_votes" */
export type FeatureVotesMaxOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  feature_id?: InputMaybe<OrderBy>;
  feedback?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  vote_type?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type FeatureVotesMinFields = {
  __typename?: "feature_votes_min_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  feature_id?: Maybe<Scalars["uuid"]["output"]>;
  feedback?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
  vote_type?: Maybe<Scalars["smallint"]["output"]>;
};

/** order by min() on columns of table "feature_votes" */
export type FeatureVotesMinOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  feature_id?: InputMaybe<OrderBy>;
  feedback?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  vote_type?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "feature_votes" */
export type FeatureVotesMutationResponse = {
  __typename?: "feature_votes_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<FeatureVotes>;
};

/** on_conflict condition type for table "feature_votes" */
export type FeatureVotesOnConflict = {
  constraint: FeatureVotesConstraint;
  update_columns?: Array<FeatureVotesUpdateColumn>;
  where?: InputMaybe<FeatureVotesBoolExp>;
};

/** Ordering options when selecting data from "feature_votes". */
export type FeatureVotesOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  feature_id?: InputMaybe<OrderBy>;
  feature_request?: InputMaybe<FeatureRequestsOrderBy>;
  feedback?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  vote_type?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: feature_votes */
export type FeatureVotesPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "feature_votes" */
export enum FeatureVotesSelectColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FEATURE_ID = "feature_id",
  /** column name */
  FEEDBACK = "feedback",
  /** column name */
  ID = "id",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
  /** column name */
  VOTE_TYPE = "vote_type",
}

/** input type for updating data in table "feature_votes" */
export type FeatureVotesSetInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  feature_id?: InputMaybe<Scalars["uuid"]["input"]>;
  feedback?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
};

/** aggregate stddev on columns */
export type FeatureVotesStddevFields = {
  __typename?: "feature_votes_stddev_fields";
  vote_type?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "feature_votes" */
export type FeatureVotesStddevOrderBy = {
  vote_type?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type FeatureVotesStddevPopFields = {
  __typename?: "feature_votes_stddev_pop_fields";
  vote_type?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "feature_votes" */
export type FeatureVotesStddevPopOrderBy = {
  vote_type?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type FeatureVotesStddevSampFields = {
  __typename?: "feature_votes_stddev_samp_fields";
  vote_type?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "feature_votes" */
export type FeatureVotesStddevSampOrderBy = {
  vote_type?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "feature_votes" */
export type FeatureVotesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: FeatureVotesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type FeatureVotesStreamCursorValueInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  feature_id?: InputMaybe<Scalars["uuid"]["input"]>;
  feedback?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
};

/** aggregate sum on columns */
export type FeatureVotesSumFields = {
  __typename?: "feature_votes_sum_fields";
  vote_type?: Maybe<Scalars["smallint"]["output"]>;
};

/** order by sum() on columns of table "feature_votes" */
export type FeatureVotesSumOrderBy = {
  vote_type?: InputMaybe<OrderBy>;
};

/** update columns of table "feature_votes" */
export enum FeatureVotesUpdateColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FEATURE_ID = "feature_id",
  /** column name */
  FEEDBACK = "feedback",
  /** column name */
  ID = "id",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
  /** column name */
  VOTE_TYPE = "vote_type",
}

export type FeatureVotesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<FeatureVotesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<FeatureVotesSetInput>;
  /** filter the rows which have to be updated */
  where: FeatureVotesBoolExp;
};

/** aggregate var_pop on columns */
export type FeatureVotesVarPopFields = {
  __typename?: "feature_votes_var_pop_fields";
  vote_type?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "feature_votes" */
export type FeatureVotesVarPopOrderBy = {
  vote_type?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type FeatureVotesVarSampFields = {
  __typename?: "feature_votes_var_samp_fields";
  vote_type?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "feature_votes" */
export type FeatureVotesVarSampOrderBy = {
  vote_type?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type FeatureVotesVarianceFields = {
  __typename?: "feature_votes_variance_fields";
  vote_type?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "feature_votes" */
export type FeatureVotesVarianceOrderBy = {
  vote_type?: InputMaybe<OrderBy>;
};

/** Categories For Custom Feeds */
export type FeedCategories = {
  __typename?: "feed_categories";
  /** An object relationship */
  category?: Maybe<Categories>;
  category_id?: Maybe<Scalars["bigint"]["output"]>;
  created_at: Scalars["timestamptz"]["output"];
  /** An object relationship */
  feed?: Maybe<Feeds>;
  feed_id?: Maybe<Scalars["uuid"]["output"]>;
  id: Scalars["bigint"]["output"];
};

/** aggregated selection of "feed_categories" */
export type FeedCategoriesAggregate = {
  __typename?: "feed_categories_aggregate";
  aggregate?: Maybe<FeedCategoriesAggregateFields>;
  nodes: Array<FeedCategories>;
};

export type FeedCategoriesAggregateBoolExp = {
  count?: InputMaybe<FeedCategoriesAggregateBoolExpCount>;
};

export type FeedCategoriesAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<FeedCategoriesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<FeedCategoriesBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "feed_categories" */
export type FeedCategoriesAggregateFields = {
  __typename?: "feed_categories_aggregate_fields";
  avg?: Maybe<FeedCategoriesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<FeedCategoriesMaxFields>;
  min?: Maybe<FeedCategoriesMinFields>;
  stddev?: Maybe<FeedCategoriesStddevFields>;
  stddev_pop?: Maybe<FeedCategoriesStddevPopFields>;
  stddev_samp?: Maybe<FeedCategoriesStddevSampFields>;
  sum?: Maybe<FeedCategoriesSumFields>;
  var_pop?: Maybe<FeedCategoriesVarPopFields>;
  var_samp?: Maybe<FeedCategoriesVarSampFields>;
  variance?: Maybe<FeedCategoriesVarianceFields>;
};

/** aggregate fields of "feed_categories" */
export type FeedCategoriesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<FeedCategoriesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "feed_categories" */
export type FeedCategoriesAggregateOrderBy = {
  avg?: InputMaybe<FeedCategoriesAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<FeedCategoriesMaxOrderBy>;
  min?: InputMaybe<FeedCategoriesMinOrderBy>;
  stddev?: InputMaybe<FeedCategoriesStddevOrderBy>;
  stddev_pop?: InputMaybe<FeedCategoriesStddevPopOrderBy>;
  stddev_samp?: InputMaybe<FeedCategoriesStddevSampOrderBy>;
  sum?: InputMaybe<FeedCategoriesSumOrderBy>;
  var_pop?: InputMaybe<FeedCategoriesVarPopOrderBy>;
  var_samp?: InputMaybe<FeedCategoriesVarSampOrderBy>;
  variance?: InputMaybe<FeedCategoriesVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "feed_categories" */
export type FeedCategoriesArrRelInsertInput = {
  data: Array<FeedCategoriesInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<FeedCategoriesOnConflict>;
};

/** aggregate avg on columns */
export type FeedCategoriesAvgFields = {
  __typename?: "feed_categories_avg_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "feed_categories" */
export type FeedCategoriesAvgOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "feed_categories". All fields are combined with a logical 'AND'. */
export type FeedCategoriesBoolExp = {
  _and?: InputMaybe<Array<FeedCategoriesBoolExp>>;
  _not?: InputMaybe<FeedCategoriesBoolExp>;
  _or?: InputMaybe<Array<FeedCategoriesBoolExp>>;
  category?: InputMaybe<CategoriesBoolExp>;
  category_id?: InputMaybe<BigintComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  feed?: InputMaybe<FeedsBoolExp>;
  feed_id?: InputMaybe<UuidComparisonExp>;
  id?: InputMaybe<BigintComparisonExp>;
};

/** unique or primary key constraints on table "feed_categories" */
export enum FeedCategoriesConstraint {
  /** unique or primary key constraint on columns "id" */
  FEED_CATEGORIES_PKEY = "feed_categories_pkey",
}

/** input type for incrementing numeric columns in table "feed_categories" */
export type FeedCategoriesIncInput = {
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** input type for inserting data into table "feed_categories" */
export type FeedCategoriesInsertInput = {
  category?: InputMaybe<CategoriesObjRelInsertInput>;
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  feed?: InputMaybe<FeedsObjRelInsertInput>;
  feed_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** aggregate max on columns */
export type FeedCategoriesMaxFields = {
  __typename?: "feed_categories_max_fields";
  category_id?: Maybe<Scalars["bigint"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  feed_id?: Maybe<Scalars["uuid"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
};

/** order by max() on columns of table "feed_categories" */
export type FeedCategoriesMaxOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  feed_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type FeedCategoriesMinFields = {
  __typename?: "feed_categories_min_fields";
  category_id?: Maybe<Scalars["bigint"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  feed_id?: Maybe<Scalars["uuid"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
};

/** order by min() on columns of table "feed_categories" */
export type FeedCategoriesMinOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  feed_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "feed_categories" */
export type FeedCategoriesMutationResponse = {
  __typename?: "feed_categories_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<FeedCategories>;
};

/** on_conflict condition type for table "feed_categories" */
export type FeedCategoriesOnConflict = {
  constraint: FeedCategoriesConstraint;
  update_columns?: Array<FeedCategoriesUpdateColumn>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

/** Ordering options when selecting data from "feed_categories". */
export type FeedCategoriesOrderBy = {
  category?: InputMaybe<CategoriesOrderBy>;
  category_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  feed?: InputMaybe<FeedsOrderBy>;
  feed_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: feed_categories */
export type FeedCategoriesPkColumnsInput = {
  id: Scalars["bigint"]["input"];
};

/** select columns of table "feed_categories" */
export enum FeedCategoriesSelectColumn {
  /** column name */
  CATEGORY_ID = "category_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FEED_ID = "feed_id",
  /** column name */
  ID = "id",
}

/** input type for updating data in table "feed_categories" */
export type FeedCategoriesSetInput = {
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  feed_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** aggregate stddev on columns */
export type FeedCategoriesStddevFields = {
  __typename?: "feed_categories_stddev_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "feed_categories" */
export type FeedCategoriesStddevOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type FeedCategoriesStddevPopFields = {
  __typename?: "feed_categories_stddev_pop_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "feed_categories" */
export type FeedCategoriesStddevPopOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type FeedCategoriesStddevSampFields = {
  __typename?: "feed_categories_stddev_samp_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "feed_categories" */
export type FeedCategoriesStddevSampOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "feed_categories" */
export type FeedCategoriesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: FeedCategoriesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type FeedCategoriesStreamCursorValueInput = {
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  feed_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** aggregate sum on columns */
export type FeedCategoriesSumFields = {
  __typename?: "feed_categories_sum_fields";
  category_id?: Maybe<Scalars["bigint"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
};

/** order by sum() on columns of table "feed_categories" */
export type FeedCategoriesSumOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** update columns of table "feed_categories" */
export enum FeedCategoriesUpdateColumn {
  /** column name */
  CATEGORY_ID = "category_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FEED_ID = "feed_id",
  /** column name */
  ID = "id",
}

export type FeedCategoriesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<FeedCategoriesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<FeedCategoriesSetInput>;
  /** filter the rows which have to be updated */
  where: FeedCategoriesBoolExp;
};

/** aggregate var_pop on columns */
export type FeedCategoriesVarPopFields = {
  __typename?: "feed_categories_var_pop_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "feed_categories" */
export type FeedCategoriesVarPopOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type FeedCategoriesVarSampFields = {
  __typename?: "feed_categories_var_samp_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "feed_categories" */
export type FeedCategoriesVarSampOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type FeedCategoriesVarianceFields = {
  __typename?: "feed_categories_variance_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "feed_categories" */
export type FeedCategoriesVarianceOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** columns and relationships of "feed_sources" */
export type FeedSources = {
  __typename?: "feed_sources";
  /** An object relationship */
  content_source?: Maybe<ContentSources>;
  content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  created_at: Scalars["timestamptz"]["output"];
  /** An object relationship */
  feed?: Maybe<Feeds>;
  feed_id?: Maybe<Scalars["uuid"]["output"]>;
  id: Scalars["bigint"]["output"];
};

/** aggregated selection of "feed_sources" */
export type FeedSourcesAggregate = {
  __typename?: "feed_sources_aggregate";
  aggregate?: Maybe<FeedSourcesAggregateFields>;
  nodes: Array<FeedSources>;
};

export type FeedSourcesAggregateBoolExp = {
  count?: InputMaybe<FeedSourcesAggregateBoolExpCount>;
};

export type FeedSourcesAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<FeedSourcesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<FeedSourcesBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "feed_sources" */
export type FeedSourcesAggregateFields = {
  __typename?: "feed_sources_aggregate_fields";
  avg?: Maybe<FeedSourcesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<FeedSourcesMaxFields>;
  min?: Maybe<FeedSourcesMinFields>;
  stddev?: Maybe<FeedSourcesStddevFields>;
  stddev_pop?: Maybe<FeedSourcesStddevPopFields>;
  stddev_samp?: Maybe<FeedSourcesStddevSampFields>;
  sum?: Maybe<FeedSourcesSumFields>;
  var_pop?: Maybe<FeedSourcesVarPopFields>;
  var_samp?: Maybe<FeedSourcesVarSampFields>;
  variance?: Maybe<FeedSourcesVarianceFields>;
};

/** aggregate fields of "feed_sources" */
export type FeedSourcesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<FeedSourcesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "feed_sources" */
export type FeedSourcesAggregateOrderBy = {
  avg?: InputMaybe<FeedSourcesAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<FeedSourcesMaxOrderBy>;
  min?: InputMaybe<FeedSourcesMinOrderBy>;
  stddev?: InputMaybe<FeedSourcesStddevOrderBy>;
  stddev_pop?: InputMaybe<FeedSourcesStddevPopOrderBy>;
  stddev_samp?: InputMaybe<FeedSourcesStddevSampOrderBy>;
  sum?: InputMaybe<FeedSourcesSumOrderBy>;
  var_pop?: InputMaybe<FeedSourcesVarPopOrderBy>;
  var_samp?: InputMaybe<FeedSourcesVarSampOrderBy>;
  variance?: InputMaybe<FeedSourcesVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "feed_sources" */
export type FeedSourcesArrRelInsertInput = {
  data: Array<FeedSourcesInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<FeedSourcesOnConflict>;
};

/** aggregate avg on columns */
export type FeedSourcesAvgFields = {
  __typename?: "feed_sources_avg_fields";
  content_source_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "feed_sources" */
export type FeedSourcesAvgOrderBy = {
  content_source_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "feed_sources". All fields are combined with a logical 'AND'. */
export type FeedSourcesBoolExp = {
  _and?: InputMaybe<Array<FeedSourcesBoolExp>>;
  _not?: InputMaybe<FeedSourcesBoolExp>;
  _or?: InputMaybe<Array<FeedSourcesBoolExp>>;
  content_source?: InputMaybe<ContentSourcesBoolExp>;
  content_source_id?: InputMaybe<BigintComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  feed?: InputMaybe<FeedsBoolExp>;
  feed_id?: InputMaybe<UuidComparisonExp>;
  id?: InputMaybe<BigintComparisonExp>;
};

/** unique or primary key constraints on table "feed_sources" */
export enum FeedSourcesConstraint {
  /** unique or primary key constraint on columns "id" */
  FEED_SOURCES_PKEY = "feed_sources_pkey",
}

/** input type for incrementing numeric columns in table "feed_sources" */
export type FeedSourcesIncInput = {
  content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** input type for inserting data into table "feed_sources" */
export type FeedSourcesInsertInput = {
  content_source?: InputMaybe<ContentSourcesObjRelInsertInput>;
  content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  feed?: InputMaybe<FeedsObjRelInsertInput>;
  feed_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate max on columns */
export type FeedSourcesMaxFields = {
  __typename?: "feed_sources_max_fields";
  content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  feed_id?: Maybe<Scalars["uuid"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
};

/** order by max() on columns of table "feed_sources" */
export type FeedSourcesMaxOrderBy = {
  content_source_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  feed_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type FeedSourcesMinFields = {
  __typename?: "feed_sources_min_fields";
  content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  feed_id?: Maybe<Scalars["uuid"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
};

/** order by min() on columns of table "feed_sources" */
export type FeedSourcesMinOrderBy = {
  content_source_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  feed_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "feed_sources" */
export type FeedSourcesMutationResponse = {
  __typename?: "feed_sources_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<FeedSources>;
};

/** on_conflict condition type for table "feed_sources" */
export type FeedSourcesOnConflict = {
  constraint: FeedSourcesConstraint;
  update_columns?: Array<FeedSourcesUpdateColumn>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

/** Ordering options when selecting data from "feed_sources". */
export type FeedSourcesOrderBy = {
  content_source?: InputMaybe<ContentSourcesOrderBy>;
  content_source_id?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  feed?: InputMaybe<FeedsOrderBy>;
  feed_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: feed_sources */
export type FeedSourcesPkColumnsInput = {
  id: Scalars["bigint"]["input"];
};

/** select columns of table "feed_sources" */
export enum FeedSourcesSelectColumn {
  /** column name */
  CONTENT_SOURCE_ID = "content_source_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FEED_ID = "feed_id",
  /** column name */
  ID = "id",
}

/** input type for updating data in table "feed_sources" */
export type FeedSourcesSetInput = {
  content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  feed_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate stddev on columns */
export type FeedSourcesStddevFields = {
  __typename?: "feed_sources_stddev_fields";
  content_source_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "feed_sources" */
export type FeedSourcesStddevOrderBy = {
  content_source_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type FeedSourcesStddevPopFields = {
  __typename?: "feed_sources_stddev_pop_fields";
  content_source_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "feed_sources" */
export type FeedSourcesStddevPopOrderBy = {
  content_source_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type FeedSourcesStddevSampFields = {
  __typename?: "feed_sources_stddev_samp_fields";
  content_source_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "feed_sources" */
export type FeedSourcesStddevSampOrderBy = {
  content_source_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "feed_sources" */
export type FeedSourcesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: FeedSourcesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type FeedSourcesStreamCursorValueInput = {
  content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  feed_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** aggregate sum on columns */
export type FeedSourcesSumFields = {
  __typename?: "feed_sources_sum_fields";
  content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
};

/** order by sum() on columns of table "feed_sources" */
export type FeedSourcesSumOrderBy = {
  content_source_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** update columns of table "feed_sources" */
export enum FeedSourcesUpdateColumn {
  /** column name */
  CONTENT_SOURCE_ID = "content_source_id",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FEED_ID = "feed_id",
}

export type FeedSourcesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<FeedSourcesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<FeedSourcesSetInput>;
  /** filter the rows which have to be updated */
  where: FeedSourcesBoolExp;
};

/** aggregate var_pop on columns */
export type FeedSourcesVarPopFields = {
  __typename?: "feed_sources_var_pop_fields";
  content_source_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "feed_sources" */
export type FeedSourcesVarPopOrderBy = {
  content_source_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type FeedSourcesVarSampFields = {
  __typename?: "feed_sources_var_samp_fields";
  content_source_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "feed_sources" */
export type FeedSourcesVarSampOrderBy = {
  content_source_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type FeedSourcesVarianceFields = {
  __typename?: "feed_sources_variance_fields";
  content_source_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "feed_sources" */
export type FeedSourcesVarianceOrderBy = {
  content_source_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Boolean expression to compare columns of type "feedback_status". All fields are combined with logical 'AND'. */
export type FeedbackStatusComparisonExp = {
  _eq?: InputMaybe<Scalars["feedback_status"]["input"]>;
  _gt?: InputMaybe<Scalars["feedback_status"]["input"]>;
  _gte?: InputMaybe<Scalars["feedback_status"]["input"]>;
  _in?: InputMaybe<Array<Scalars["feedback_status"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["feedback_status"]["input"]>;
  _lte?: InputMaybe<Scalars["feedback_status"]["input"]>;
  _neq?: InputMaybe<Scalars["feedback_status"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["feedback_status"]["input"]>>;
};

/** Boolean expression to compare columns of type "feedback_type". All fields are combined with logical 'AND'. */
export type FeedbackTypeComparisonExp = {
  _eq?: InputMaybe<Scalars["feedback_type"]["input"]>;
  _gt?: InputMaybe<Scalars["feedback_type"]["input"]>;
  _gte?: InputMaybe<Scalars["feedback_type"]["input"]>;
  _in?: InputMaybe<Array<Scalars["feedback_type"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["feedback_type"]["input"]>;
  _lte?: InputMaybe<Scalars["feedback_type"]["input"]>;
  _neq?: InputMaybe<Scalars["feedback_type"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["feedback_type"]["input"]>>;
};

/** columns and relationships of "feedbacks" */
export type Feedbacks = {
  __typename?: "feedbacks";
  created_at: Scalars["timestamptz"]["output"];
  device_info?: Maybe<Scalars["String"]["output"]>;
  feedback_status?: Maybe<Scalars["feedback_status"]["output"]>;
  feedback_type?: Maybe<Scalars["feedback_type"]["output"]>;
  id: Scalars["Int"]["output"];
  message: Scalars["String"]["output"];
  page_identifier: Scalars["String"]["output"];
  rating?: Maybe<Scalars["Int"]["output"]>;
  resolution_comment?: Maybe<Scalars["String"]["output"]>;
  updated_at: Scalars["timestamptz"]["output"];
  user_id?: Maybe<Scalars["uuid"]["output"]>;
  /** An object relationship */
  user_profile?: Maybe<UserProfiles>;
};

/** aggregated selection of "feedbacks" */
export type FeedbacksAggregate = {
  __typename?: "feedbacks_aggregate";
  aggregate?: Maybe<FeedbacksAggregateFields>;
  nodes: Array<Feedbacks>;
};

export type FeedbacksAggregateBoolExp = {
  count?: InputMaybe<FeedbacksAggregateBoolExpCount>;
};

export type FeedbacksAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<FeedbacksSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<FeedbacksBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "feedbacks" */
export type FeedbacksAggregateFields = {
  __typename?: "feedbacks_aggregate_fields";
  avg?: Maybe<FeedbacksAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<FeedbacksMaxFields>;
  min?: Maybe<FeedbacksMinFields>;
  stddev?: Maybe<FeedbacksStddevFields>;
  stddev_pop?: Maybe<FeedbacksStddevPopFields>;
  stddev_samp?: Maybe<FeedbacksStddevSampFields>;
  sum?: Maybe<FeedbacksSumFields>;
  var_pop?: Maybe<FeedbacksVarPopFields>;
  var_samp?: Maybe<FeedbacksVarSampFields>;
  variance?: Maybe<FeedbacksVarianceFields>;
};

/** aggregate fields of "feedbacks" */
export type FeedbacksAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<FeedbacksSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "feedbacks" */
export type FeedbacksAggregateOrderBy = {
  avg?: InputMaybe<FeedbacksAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<FeedbacksMaxOrderBy>;
  min?: InputMaybe<FeedbacksMinOrderBy>;
  stddev?: InputMaybe<FeedbacksStddevOrderBy>;
  stddev_pop?: InputMaybe<FeedbacksStddevPopOrderBy>;
  stddev_samp?: InputMaybe<FeedbacksStddevSampOrderBy>;
  sum?: InputMaybe<FeedbacksSumOrderBy>;
  var_pop?: InputMaybe<FeedbacksVarPopOrderBy>;
  var_samp?: InputMaybe<FeedbacksVarSampOrderBy>;
  variance?: InputMaybe<FeedbacksVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "feedbacks" */
export type FeedbacksArrRelInsertInput = {
  data: Array<FeedbacksInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<FeedbacksOnConflict>;
};

/** aggregate avg on columns */
export type FeedbacksAvgFields = {
  __typename?: "feedbacks_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  rating?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "feedbacks" */
export type FeedbacksAvgOrderBy = {
  id?: InputMaybe<OrderBy>;
  rating?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "feedbacks". All fields are combined with a logical 'AND'. */
export type FeedbacksBoolExp = {
  _and?: InputMaybe<Array<FeedbacksBoolExp>>;
  _not?: InputMaybe<FeedbacksBoolExp>;
  _or?: InputMaybe<Array<FeedbacksBoolExp>>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  device_info?: InputMaybe<StringComparisonExp>;
  feedback_status?: InputMaybe<FeedbackStatusComparisonExp>;
  feedback_type?: InputMaybe<FeedbackTypeComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  message?: InputMaybe<StringComparisonExp>;
  page_identifier?: InputMaybe<StringComparisonExp>;
  rating?: InputMaybe<IntComparisonExp>;
  resolution_comment?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
  user_profile?: InputMaybe<UserProfilesBoolExp>;
};

/** unique or primary key constraints on table "feedbacks" */
export enum FeedbacksConstraint {
  /** unique or primary key constraint on columns "id" */
  FEEDBACK_PKEY = "feedback_pkey",
}

/** input type for incrementing numeric columns in table "feedbacks" */
export type FeedbacksIncInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
  rating?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "feedbacks" */
export type FeedbacksInsertInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  device_info?: InputMaybe<Scalars["String"]["input"]>;
  feedback_status?: InputMaybe<Scalars["feedback_status"]["input"]>;
  feedback_type?: InputMaybe<Scalars["feedback_type"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  message?: InputMaybe<Scalars["String"]["input"]>;
  page_identifier?: InputMaybe<Scalars["String"]["input"]>;
  rating?: InputMaybe<Scalars["Int"]["input"]>;
  resolution_comment?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
};

/** aggregate max on columns */
export type FeedbacksMaxFields = {
  __typename?: "feedbacks_max_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  device_info?: Maybe<Scalars["String"]["output"]>;
  feedback_status?: Maybe<Scalars["feedback_status"]["output"]>;
  feedback_type?: Maybe<Scalars["feedback_type"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  message?: Maybe<Scalars["String"]["output"]>;
  page_identifier?: Maybe<Scalars["String"]["output"]>;
  rating?: Maybe<Scalars["Int"]["output"]>;
  resolution_comment?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by max() on columns of table "feedbacks" */
export type FeedbacksMaxOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  device_info?: InputMaybe<OrderBy>;
  feedback_status?: InputMaybe<OrderBy>;
  feedback_type?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  message?: InputMaybe<OrderBy>;
  page_identifier?: InputMaybe<OrderBy>;
  rating?: InputMaybe<OrderBy>;
  resolution_comment?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type FeedbacksMinFields = {
  __typename?: "feedbacks_min_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  device_info?: Maybe<Scalars["String"]["output"]>;
  feedback_status?: Maybe<Scalars["feedback_status"]["output"]>;
  feedback_type?: Maybe<Scalars["feedback_type"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  message?: Maybe<Scalars["String"]["output"]>;
  page_identifier?: Maybe<Scalars["String"]["output"]>;
  rating?: Maybe<Scalars["Int"]["output"]>;
  resolution_comment?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by min() on columns of table "feedbacks" */
export type FeedbacksMinOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  device_info?: InputMaybe<OrderBy>;
  feedback_status?: InputMaybe<OrderBy>;
  feedback_type?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  message?: InputMaybe<OrderBy>;
  page_identifier?: InputMaybe<OrderBy>;
  rating?: InputMaybe<OrderBy>;
  resolution_comment?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "feedbacks" */
export type FeedbacksMutationResponse = {
  __typename?: "feedbacks_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Feedbacks>;
};

/** on_conflict condition type for table "feedbacks" */
export type FeedbacksOnConflict = {
  constraint: FeedbacksConstraint;
  update_columns?: Array<FeedbacksUpdateColumn>;
  where?: InputMaybe<FeedbacksBoolExp>;
};

/** Ordering options when selecting data from "feedbacks". */
export type FeedbacksOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  device_info?: InputMaybe<OrderBy>;
  feedback_status?: InputMaybe<OrderBy>;
  feedback_type?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  message?: InputMaybe<OrderBy>;
  page_identifier?: InputMaybe<OrderBy>;
  rating?: InputMaybe<OrderBy>;
  resolution_comment?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  user_profile?: InputMaybe<UserProfilesOrderBy>;
};

/** primary key columns input for table: feedbacks */
export type FeedbacksPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "feedbacks" */
export enum FeedbacksSelectColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DEVICE_INFO = "device_info",
  /** column name */
  FEEDBACK_STATUS = "feedback_status",
  /** column name */
  FEEDBACK_TYPE = "feedback_type",
  /** column name */
  ID = "id",
  /** column name */
  MESSAGE = "message",
  /** column name */
  PAGE_IDENTIFIER = "page_identifier",
  /** column name */
  RATING = "rating",
  /** column name */
  RESOLUTION_COMMENT = "resolution_comment",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

/** input type for updating data in table "feedbacks" */
export type FeedbacksSetInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  device_info?: InputMaybe<Scalars["String"]["input"]>;
  feedback_status?: InputMaybe<Scalars["feedback_status"]["input"]>;
  feedback_type?: InputMaybe<Scalars["feedback_type"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  message?: InputMaybe<Scalars["String"]["input"]>;
  page_identifier?: InputMaybe<Scalars["String"]["input"]>;
  rating?: InputMaybe<Scalars["Int"]["input"]>;
  resolution_comment?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate stddev on columns */
export type FeedbacksStddevFields = {
  __typename?: "feedbacks_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  rating?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "feedbacks" */
export type FeedbacksStddevOrderBy = {
  id?: InputMaybe<OrderBy>;
  rating?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type FeedbacksStddevPopFields = {
  __typename?: "feedbacks_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  rating?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "feedbacks" */
export type FeedbacksStddevPopOrderBy = {
  id?: InputMaybe<OrderBy>;
  rating?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type FeedbacksStddevSampFields = {
  __typename?: "feedbacks_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  rating?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "feedbacks" */
export type FeedbacksStddevSampOrderBy = {
  id?: InputMaybe<OrderBy>;
  rating?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "feedbacks" */
export type FeedbacksStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: FeedbacksStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type FeedbacksStreamCursorValueInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  device_info?: InputMaybe<Scalars["String"]["input"]>;
  feedback_status?: InputMaybe<Scalars["feedback_status"]["input"]>;
  feedback_type?: InputMaybe<Scalars["feedback_type"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  message?: InputMaybe<Scalars["String"]["input"]>;
  page_identifier?: InputMaybe<Scalars["String"]["input"]>;
  rating?: InputMaybe<Scalars["Int"]["input"]>;
  resolution_comment?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate sum on columns */
export type FeedbacksSumFields = {
  __typename?: "feedbacks_sum_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
  rating?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "feedbacks" */
export type FeedbacksSumOrderBy = {
  id?: InputMaybe<OrderBy>;
  rating?: InputMaybe<OrderBy>;
};

/** update columns of table "feedbacks" */
export enum FeedbacksUpdateColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DEVICE_INFO = "device_info",
  /** column name */
  FEEDBACK_STATUS = "feedback_status",
  /** column name */
  FEEDBACK_TYPE = "feedback_type",
  /** column name */
  ID = "id",
  /** column name */
  MESSAGE = "message",
  /** column name */
  PAGE_IDENTIFIER = "page_identifier",
  /** column name */
  RATING = "rating",
  /** column name */
  RESOLUTION_COMMENT = "resolution_comment",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USER_ID = "user_id",
}

export type FeedbacksUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<FeedbacksIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<FeedbacksSetInput>;
  /** filter the rows which have to be updated */
  where: FeedbacksBoolExp;
};

/** aggregate var_pop on columns */
export type FeedbacksVarPopFields = {
  __typename?: "feedbacks_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  rating?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "feedbacks" */
export type FeedbacksVarPopOrderBy = {
  id?: InputMaybe<OrderBy>;
  rating?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type FeedbacksVarSampFields = {
  __typename?: "feedbacks_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  rating?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "feedbacks" */
export type FeedbacksVarSampOrderBy = {
  id?: InputMaybe<OrderBy>;
  rating?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type FeedbacksVarianceFields = {
  __typename?: "feedbacks_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  rating?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "feedbacks" */
export type FeedbacksVarianceOrderBy = {
  id?: InputMaybe<OrderBy>;
  rating?: InputMaybe<OrderBy>;
};

/** Custom Feeds For Users */
export type Feeds = {
  __typename?: "feeds";
  created_at: Scalars["timestamptz"]["output"];
  /** An array relationship */
  feed_categories: Array<FeedCategories>;
  /** An aggregate relationship */
  feed_categories_aggregate: FeedCategoriesAggregate;
  /** An array relationship */
  feed_sources: Array<FeedSources>;
  /** An aggregate relationship */
  feed_sources_aggregate: FeedSourcesAggregate;
  id: Scalars["uuid"]["output"];
  name?: Maybe<Scalars["String"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
  /** An object relationship */
  user_profile?: Maybe<UserProfiles>;
};

/** Custom Feeds For Users */
export type FeedsFeedCategoriesArgs = {
  distinct_on?: InputMaybe<Array<FeedCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedCategoriesOrderBy>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

/** Custom Feeds For Users */
export type FeedsFeedCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeedCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedCategoriesOrderBy>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

/** Custom Feeds For Users */
export type FeedsFeedSourcesArgs = {
  distinct_on?: InputMaybe<Array<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

/** Custom Feeds For Users */
export type FeedsFeedSourcesAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

/** aggregated selection of "feeds" */
export type FeedsAggregate = {
  __typename?: "feeds_aggregate";
  aggregate?: Maybe<FeedsAggregateFields>;
  nodes: Array<Feeds>;
};

export type FeedsAggregateBoolExp = {
  count?: InputMaybe<FeedsAggregateBoolExpCount>;
};

export type FeedsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<FeedsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<FeedsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "feeds" */
export type FeedsAggregateFields = {
  __typename?: "feeds_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<FeedsMaxFields>;
  min?: Maybe<FeedsMinFields>;
};

/** aggregate fields of "feeds" */
export type FeedsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<FeedsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "feeds" */
export type FeedsAggregateOrderBy = {
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<FeedsMaxOrderBy>;
  min?: InputMaybe<FeedsMinOrderBy>;
};

/** input type for inserting array relation for remote table "feeds" */
export type FeedsArrRelInsertInput = {
  data: Array<FeedsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<FeedsOnConflict>;
};

/** Boolean expression to filter rows from the table "feeds". All fields are combined with a logical 'AND'. */
export type FeedsBoolExp = {
  _and?: InputMaybe<Array<FeedsBoolExp>>;
  _not?: InputMaybe<FeedsBoolExp>;
  _or?: InputMaybe<Array<FeedsBoolExp>>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  feed_categories?: InputMaybe<FeedCategoriesBoolExp>;
  feed_categories_aggregate?: InputMaybe<FeedCategoriesAggregateBoolExp>;
  feed_sources?: InputMaybe<FeedSourcesBoolExp>;
  feed_sources_aggregate?: InputMaybe<FeedSourcesAggregateBoolExp>;
  id?: InputMaybe<UuidComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
  user_profile?: InputMaybe<UserProfilesBoolExp>;
};

/** unique or primary key constraints on table "feeds" */
export enum FeedsConstraint {
  /** unique or primary key constraint on columns "id" */
  FEEDS_PKEY = "feeds_pkey",
}

/** input type for inserting data into table "feeds" */
export type FeedsInsertInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  feed_categories?: InputMaybe<FeedCategoriesArrRelInsertInput>;
  feed_sources?: InputMaybe<FeedSourcesArrRelInsertInput>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
};

/** aggregate max on columns */
export type FeedsMaxFields = {
  __typename?: "feeds_max_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by max() on columns of table "feeds" */
export type FeedsMaxOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type FeedsMinFields = {
  __typename?: "feeds_min_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by min() on columns of table "feeds" */
export type FeedsMinOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "feeds" */
export type FeedsMutationResponse = {
  __typename?: "feeds_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Feeds>;
};

/** input type for inserting object relation for remote table "feeds" */
export type FeedsObjRelInsertInput = {
  data: FeedsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<FeedsOnConflict>;
};

/** on_conflict condition type for table "feeds" */
export type FeedsOnConflict = {
  constraint: FeedsConstraint;
  update_columns?: Array<FeedsUpdateColumn>;
  where?: InputMaybe<FeedsBoolExp>;
};

/** Ordering options when selecting data from "feeds". */
export type FeedsOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  feed_categories_aggregate?: InputMaybe<FeedCategoriesAggregateOrderBy>;
  feed_sources_aggregate?: InputMaybe<FeedSourcesAggregateOrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  user_profile?: InputMaybe<UserProfilesOrderBy>;
};

/** primary key columns input for table: feeds */
export type FeedsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "feeds" */
export enum FeedsSelectColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
  /** column name */
  USER_ID = "user_id",
}

/** input type for updating data in table "feeds" */
export type FeedsSetInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** Streaming cursor of the table "feeds" */
export type FeedsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: FeedsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type FeedsStreamCursorValueInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** update columns of table "feeds" */
export enum FeedsUpdateColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
  /** column name */
  USER_ID = "user_id",
}

export type FeedsUpdates = {
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<FeedsSetInput>;
  /** filter the rows which have to be updated */
  where: FeedsBoolExp;
};

/** Boolean expression to compare columns of type "float8". All fields are combined with logical 'AND'. */
export type Float8ComparisonExp = {
  _eq?: InputMaybe<Scalars["float8"]["input"]>;
  _gt?: InputMaybe<Scalars["float8"]["input"]>;
  _gte?: InputMaybe<Scalars["float8"]["input"]>;
  _in?: InputMaybe<Array<Scalars["float8"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["float8"]["input"]>;
  _lte?: InputMaybe<Scalars["float8"]["input"]>;
  _neq?: InputMaybe<Scalars["float8"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["float8"]["input"]>>;
};

/** Boolean expression to compare columns of type "followed_entity". All fields are combined with logical 'AND'. */
export type FollowedEntityComparisonExp = {
  _eq?: InputMaybe<Scalars["followed_entity"]["input"]>;
  _gt?: InputMaybe<Scalars["followed_entity"]["input"]>;
  _gte?: InputMaybe<Scalars["followed_entity"]["input"]>;
  _in?: InputMaybe<Array<Scalars["followed_entity"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["followed_entity"]["input"]>;
  _lte?: InputMaybe<Scalars["followed_entity"]["input"]>;
  _neq?: InputMaybe<Scalars["followed_entity"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["followed_entity"]["input"]>>;
};

/** columns and relationships of "follows" */
export type Follows = {
  __typename?: "follows";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  followed_entity: Scalars["followed_entity"]["output"];
  followed_id: Scalars["uuid"]["output"];
  id: Scalars["uuid"]["output"];
  user_id: Scalars["uuid"]["output"];
  /** An object relationship */
  user_profile: UserProfiles;
};

/** aggregated selection of "follows" */
export type FollowsAggregate = {
  __typename?: "follows_aggregate";
  aggregate?: Maybe<FollowsAggregateFields>;
  nodes: Array<Follows>;
};

export type FollowsAggregateBoolExp = {
  count?: InputMaybe<FollowsAggregateBoolExpCount>;
};

export type FollowsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<FollowsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<FollowsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "follows" */
export type FollowsAggregateFields = {
  __typename?: "follows_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<FollowsMaxFields>;
  min?: Maybe<FollowsMinFields>;
};

/** aggregate fields of "follows" */
export type FollowsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<FollowsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "follows" */
export type FollowsAggregateOrderBy = {
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<FollowsMaxOrderBy>;
  min?: InputMaybe<FollowsMinOrderBy>;
};

/** input type for inserting array relation for remote table "follows" */
export type FollowsArrRelInsertInput = {
  data: Array<FollowsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<FollowsOnConflict>;
};

/** Boolean expression to filter rows from the table "follows". All fields are combined with a logical 'AND'. */
export type FollowsBoolExp = {
  _and?: InputMaybe<Array<FollowsBoolExp>>;
  _not?: InputMaybe<FollowsBoolExp>;
  _or?: InputMaybe<Array<FollowsBoolExp>>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  followed_entity?: InputMaybe<FollowedEntityComparisonExp>;
  followed_id?: InputMaybe<UuidComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
  user_profile?: InputMaybe<UserProfilesBoolExp>;
};

/** unique or primary key constraints on table "follows" */
export enum FollowsConstraint {
  /** unique or primary key constraint on columns "id" */
  FOLLOWS_PKEY = "follows_pkey",
  /** unique or primary key constraint on columns "user_id", "followed_entity", "followed_id" */
  FOLLOWS_UNIQUE_FOLLOWER_FOLLOWING_IDX = "follows_unique_follower_following_idx",
}

/** input type for inserting data into table "follows" */
export type FollowsInsertInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  followed_entity?: InputMaybe<Scalars["followed_entity"]["input"]>;
  followed_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
};

/** aggregate max on columns */
export type FollowsMaxFields = {
  __typename?: "follows_max_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  followed_entity?: Maybe<Scalars["followed_entity"]["output"]>;
  followed_id?: Maybe<Scalars["uuid"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by max() on columns of table "follows" */
export type FollowsMaxOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  followed_entity?: InputMaybe<OrderBy>;
  followed_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type FollowsMinFields = {
  __typename?: "follows_min_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  followed_entity?: Maybe<Scalars["followed_entity"]["output"]>;
  followed_id?: Maybe<Scalars["uuid"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** order by min() on columns of table "follows" */
export type FollowsMinOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  followed_entity?: InputMaybe<OrderBy>;
  followed_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "follows" */
export type FollowsMutationResponse = {
  __typename?: "follows_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Follows>;
};

/** on_conflict condition type for table "follows" */
export type FollowsOnConflict = {
  constraint: FollowsConstraint;
  update_columns?: Array<FollowsUpdateColumn>;
  where?: InputMaybe<FollowsBoolExp>;
};

/** Ordering options when selecting data from "follows". */
export type FollowsOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  followed_entity?: InputMaybe<OrderBy>;
  followed_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  user_profile?: InputMaybe<UserProfilesOrderBy>;
};

/** primary key columns input for table: follows */
export type FollowsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "follows" */
export enum FollowsSelectColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FOLLOWED_ENTITY = "followed_entity",
  /** column name */
  FOLLOWED_ID = "followed_id",
  /** column name */
  ID = "id",
  /** column name */
  USER_ID = "user_id",
}

/** input type for updating data in table "follows" */
export type FollowsSetInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  followed_entity?: InputMaybe<Scalars["followed_entity"]["input"]>;
  followed_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** Streaming cursor of the table "follows" */
export type FollowsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: FollowsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type FollowsStreamCursorValueInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  followed_entity?: InputMaybe<Scalars["followed_entity"]["input"]>;
  followed_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** update columns of table "follows" */
export enum FollowsUpdateColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FOLLOWED_ENTITY = "followed_entity",
  /** column name */
  FOLLOWED_ID = "followed_id",
  /** column name */
  ID = "id",
  /** column name */
  USER_ID = "user_id",
}

export type FollowsUpdates = {
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<FollowsSetInput>;
  /** filter the rows which have to be updated */
  where: FollowsBoolExp;
};

/** Boolean expression to compare columns of type "inet". All fields are combined with logical 'AND'. */
export type InetComparisonExp = {
  _eq?: InputMaybe<Scalars["inet"]["input"]>;
  _gt?: InputMaybe<Scalars["inet"]["input"]>;
  _gte?: InputMaybe<Scalars["inet"]["input"]>;
  _in?: InputMaybe<Array<Scalars["inet"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["inet"]["input"]>;
  _lte?: InputMaybe<Scalars["inet"]["input"]>;
  _neq?: InputMaybe<Scalars["inet"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["inet"]["input"]>>;
};

/** Boolean expression to compare columns of type "interval". All fields are combined with logical 'AND'. */
export type IntervalComparisonExp = {
  _eq?: InputMaybe<Scalars["interval"]["input"]>;
  _gt?: InputMaybe<Scalars["interval"]["input"]>;
  _gte?: InputMaybe<Scalars["interval"]["input"]>;
  _in?: InputMaybe<Array<Scalars["interval"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["interval"]["input"]>;
  _lte?: InputMaybe<Scalars["interval"]["input"]>;
  _neq?: InputMaybe<Scalars["interval"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["interval"]["input"]>>;
};

/** Boolean expression to compare columns of type "job_status". All fields are combined with logical 'AND'. */
export type JobStatusComparisonExp = {
  _eq?: InputMaybe<Scalars["job_status"]["input"]>;
  _gt?: InputMaybe<Scalars["job_status"]["input"]>;
  _gte?: InputMaybe<Scalars["job_status"]["input"]>;
  _in?: InputMaybe<Array<Scalars["job_status"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["job_status"]["input"]>;
  _lte?: InputMaybe<Scalars["job_status"]["input"]>;
  _neq?: InputMaybe<Scalars["job_status"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["job_status"]["input"]>>;
};

export type JsonbCastExp = {
  String?: InputMaybe<StringComparisonExp>;
};

/** Boolean expression to compare columns of type "jsonb". All fields are combined with logical 'AND'. */
export type JsonbComparisonExp = {
  _cast?: InputMaybe<JsonbCastExp>;
  /** is the column contained in the given json value */
  _contained_in?: InputMaybe<Scalars["jsonb"]["input"]>;
  /** does the column contain the given json value at the top level */
  _contains?: InputMaybe<Scalars["jsonb"]["input"]>;
  _eq?: InputMaybe<Scalars["jsonb"]["input"]>;
  _gt?: InputMaybe<Scalars["jsonb"]["input"]>;
  _gte?: InputMaybe<Scalars["jsonb"]["input"]>;
  /** does the string exist as a top-level key in the column */
  _has_key?: InputMaybe<Scalars["String"]["input"]>;
  /** do all of these strings exist as top-level keys in the column */
  _has_keys_all?: InputMaybe<Array<Scalars["String"]["input"]>>;
  /** do any of these strings exist as top-level keys in the column */
  _has_keys_any?: InputMaybe<Array<Scalars["String"]["input"]>>;
  _in?: InputMaybe<Array<Scalars["jsonb"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["jsonb"]["input"]>;
  _lte?: InputMaybe<Scalars["jsonb"]["input"]>;
  _neq?: InputMaybe<Scalars["jsonb"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["jsonb"]["input"]>>;
};

/** Boolean expression to compare columns of type "ltree". All fields are combined with logical 'AND'. */
export type LtreeComparisonExp = {
  /** is the left argument an ancestor of right (or equal)? */
  _ancestor?: InputMaybe<Scalars["ltree"]["input"]>;
  /** does array contain an ancestor of `ltree`? */
  _ancestor_any?: InputMaybe<Array<Scalars["ltree"]["input"]>>;
  /** is the left argument a descendant of right (or equal)? */
  _descendant?: InputMaybe<Scalars["ltree"]["input"]>;
  /** does array contain a descendant of `ltree`? */
  _descendant_any?: InputMaybe<Array<Scalars["ltree"]["input"]>>;
  _eq?: InputMaybe<Scalars["ltree"]["input"]>;
  _gt?: InputMaybe<Scalars["ltree"]["input"]>;
  _gte?: InputMaybe<Scalars["ltree"]["input"]>;
  _in?: InputMaybe<Array<Scalars["ltree"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["ltree"]["input"]>;
  _lte?: InputMaybe<Scalars["ltree"]["input"]>;
  /** does `ltree` match `lquery`? */
  _matches?: InputMaybe<Scalars["lquery"]["input"]>;
  /** does `ltree` match any `lquery` in array? */
  _matches_any?: InputMaybe<Array<Scalars["String"]["input"]>>;
  /** does `ltree` match `ltxtquery`? */
  _matches_fulltext?: InputMaybe<Scalars["ltxtquery"]["input"]>;
  _neq?: InputMaybe<Scalars["ltree"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["ltree"]["input"]>>;
};

export type MatchResearchArgs = {
  match_count?: InputMaybe<Scalars["Int"]["input"]>;
  match_threshold?: InputMaybe<Scalars["float8"]["input"]>;
  query_embedding?: InputMaybe<Scalars["vector"]["input"]>;
};

/** columns and relationships of "metric_definitions" */
export type MetricDefinitions = {
  __typename?: "metric_definitions";
  category?: Maybe<Scalars["String"]["output"]>;
  /** An array relationship */
  company_metrics: Array<CompanyMetrics>;
  /** An aggregate relationship */
  company_metrics_aggregate: CompanyMetricsAggregate;
  description?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["Int"]["output"];
  is_dimensional?: Maybe<Scalars["Boolean"]["output"]>;
  name: Scalars["String"]["output"];
  /** An array relationship */
  spider_metrics: Array<SpiderMetrics>;
  /** An aggregate relationship */
  spider_metrics_aggregate: SpiderMetricsAggregate;
  type: Scalars["String"]["output"];
  unit?: Maybe<Scalars["String"]["output"]>;
};

/** columns and relationships of "metric_definitions" */
export type MetricDefinitionsCompanyMetricsArgs = {
  distinct_on?: InputMaybe<Array<CompanyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyMetricsOrderBy>>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
};

/** columns and relationships of "metric_definitions" */
export type MetricDefinitionsCompanyMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompanyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyMetricsOrderBy>>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
};

/** columns and relationships of "metric_definitions" */
export type MetricDefinitionsSpiderMetricsArgs = {
  distinct_on?: InputMaybe<Array<SpiderMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SpiderMetricsOrderBy>>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
};

/** columns and relationships of "metric_definitions" */
export type MetricDefinitionsSpiderMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<SpiderMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SpiderMetricsOrderBy>>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
};

/** aggregated selection of "metric_definitions" */
export type MetricDefinitionsAggregate = {
  __typename?: "metric_definitions_aggregate";
  aggregate?: Maybe<MetricDefinitionsAggregateFields>;
  nodes: Array<MetricDefinitions>;
};

/** aggregate fields of "metric_definitions" */
export type MetricDefinitionsAggregateFields = {
  __typename?: "metric_definitions_aggregate_fields";
  avg?: Maybe<MetricDefinitionsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<MetricDefinitionsMaxFields>;
  min?: Maybe<MetricDefinitionsMinFields>;
  stddev?: Maybe<MetricDefinitionsStddevFields>;
  stddev_pop?: Maybe<MetricDefinitionsStddevPopFields>;
  stddev_samp?: Maybe<MetricDefinitionsStddevSampFields>;
  sum?: Maybe<MetricDefinitionsSumFields>;
  var_pop?: Maybe<MetricDefinitionsVarPopFields>;
  var_samp?: Maybe<MetricDefinitionsVarSampFields>;
  variance?: Maybe<MetricDefinitionsVarianceFields>;
};

/** aggregate fields of "metric_definitions" */
export type MetricDefinitionsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<MetricDefinitionsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type MetricDefinitionsAvgFields = {
  __typename?: "metric_definitions_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "metric_definitions". All fields are combined with a logical 'AND'. */
export type MetricDefinitionsBoolExp = {
  _and?: InputMaybe<Array<MetricDefinitionsBoolExp>>;
  _not?: InputMaybe<MetricDefinitionsBoolExp>;
  _or?: InputMaybe<Array<MetricDefinitionsBoolExp>>;
  category?: InputMaybe<StringComparisonExp>;
  company_metrics?: InputMaybe<CompanyMetricsBoolExp>;
  company_metrics_aggregate?: InputMaybe<CompanyMetricsAggregateBoolExp>;
  description?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  is_dimensional?: InputMaybe<BooleanComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  spider_metrics?: InputMaybe<SpiderMetricsBoolExp>;
  spider_metrics_aggregate?: InputMaybe<SpiderMetricsAggregateBoolExp>;
  type?: InputMaybe<StringComparisonExp>;
  unit?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "metric_definitions" */
export enum MetricDefinitionsConstraint {
  /** unique or primary key constraint on columns "category", "name" */
  METRIC_DEFINITIONS_NAME_CATEGORY_KEY = "metric_definitions_name_category_key",
  /** unique or primary key constraint on columns "id" */
  METRIC_DEFINITIONS_PKEY = "metric_definitions_pkey",
}

/** input type for incrementing numeric columns in table "metric_definitions" */
export type MetricDefinitionsIncInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "metric_definitions" */
export type MetricDefinitionsInsertInput = {
  category?: InputMaybe<Scalars["String"]["input"]>;
  company_metrics?: InputMaybe<CompanyMetricsArrRelInsertInput>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  is_dimensional?: InputMaybe<Scalars["Boolean"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  spider_metrics?: InputMaybe<SpiderMetricsArrRelInsertInput>;
  type?: InputMaybe<Scalars["String"]["input"]>;
  unit?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type MetricDefinitionsMaxFields = {
  __typename?: "metric_definitions_max_fields";
  category?: Maybe<Scalars["String"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  type?: Maybe<Scalars["String"]["output"]>;
  unit?: Maybe<Scalars["String"]["output"]>;
};

/** aggregate min on columns */
export type MetricDefinitionsMinFields = {
  __typename?: "metric_definitions_min_fields";
  category?: Maybe<Scalars["String"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  type?: Maybe<Scalars["String"]["output"]>;
  unit?: Maybe<Scalars["String"]["output"]>;
};

/** response of any mutation on the table "metric_definitions" */
export type MetricDefinitionsMutationResponse = {
  __typename?: "metric_definitions_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<MetricDefinitions>;
};

/** input type for inserting object relation for remote table "metric_definitions" */
export type MetricDefinitionsObjRelInsertInput = {
  data: MetricDefinitionsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<MetricDefinitionsOnConflict>;
};

/** on_conflict condition type for table "metric_definitions" */
export type MetricDefinitionsOnConflict = {
  constraint: MetricDefinitionsConstraint;
  update_columns?: Array<MetricDefinitionsUpdateColumn>;
  where?: InputMaybe<MetricDefinitionsBoolExp>;
};

/** Ordering options when selecting data from "metric_definitions". */
export type MetricDefinitionsOrderBy = {
  category?: InputMaybe<OrderBy>;
  company_metrics_aggregate?: InputMaybe<CompanyMetricsAggregateOrderBy>;
  description?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  is_dimensional?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  spider_metrics_aggregate?: InputMaybe<SpiderMetricsAggregateOrderBy>;
  type?: InputMaybe<OrderBy>;
  unit?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: metric_definitions */
export type MetricDefinitionsPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "metric_definitions" */
export enum MetricDefinitionsSelectColumn {
  /** column name */
  CATEGORY = "category",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  ID = "id",
  /** column name */
  IS_DIMENSIONAL = "is_dimensional",
  /** column name */
  NAME = "name",
  /** column name */
  TYPE = "type",
  /** column name */
  UNIT = "unit",
}

/** input type for updating data in table "metric_definitions" */
export type MetricDefinitionsSetInput = {
  category?: InputMaybe<Scalars["String"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  is_dimensional?: InputMaybe<Scalars["Boolean"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  type?: InputMaybe<Scalars["String"]["input"]>;
  unit?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type MetricDefinitionsStddevFields = {
  __typename?: "metric_definitions_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type MetricDefinitionsStddevPopFields = {
  __typename?: "metric_definitions_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type MetricDefinitionsStddevSampFields = {
  __typename?: "metric_definitions_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "metric_definitions" */
export type MetricDefinitionsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: MetricDefinitionsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type MetricDefinitionsStreamCursorValueInput = {
  category?: InputMaybe<Scalars["String"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  is_dimensional?: InputMaybe<Scalars["Boolean"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  type?: InputMaybe<Scalars["String"]["input"]>;
  unit?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type MetricDefinitionsSumFields = {
  __typename?: "metric_definitions_sum_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "metric_definitions" */
export enum MetricDefinitionsUpdateColumn {
  /** column name */
  CATEGORY = "category",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  ID = "id",
  /** column name */
  IS_DIMENSIONAL = "is_dimensional",
  /** column name */
  NAME = "name",
  /** column name */
  TYPE = "type",
  /** column name */
  UNIT = "unit",
}

export type MetricDefinitionsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<MetricDefinitionsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<MetricDefinitionsSetInput>;
  /** filter the rows which have to be updated */
  where: MetricDefinitionsBoolExp;
};

/** aggregate var_pop on columns */
export type MetricDefinitionsVarPopFields = {
  __typename?: "metric_definitions_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type MetricDefinitionsVarSampFields = {
  __typename?: "metric_definitions_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type MetricDefinitionsVarianceFields = {
  __typename?: "metric_definitions_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** mutation root */
export type MutationRoot = {
  __typename?: "mutation_root";
  /** delete data from the table: "ad_daily_metrics" */
  delete_ad_daily_metrics?: Maybe<AdDailyMetricsMutationResponse>;
  /** delete single row from the table: "ad_daily_metrics" */
  delete_ad_daily_metrics_by_pk?: Maybe<AdDailyMetrics>;
  /** delete data from the table: "ad_packages" */
  delete_ad_packages?: Maybe<AdPackagesMutationResponse>;
  /** delete single row from the table: "ad_packages" */
  delete_ad_packages_by_pk?: Maybe<AdPackages>;
  /** delete data from the table: "ad_variants" */
  delete_ad_variants?: Maybe<AdVariantsMutationResponse>;
  /** delete single row from the table: "ad_variants" */
  delete_ad_variants_by_pk?: Maybe<AdVariants>;
  /** delete data from the table: "addresses" */
  delete_addresses?: Maybe<AddressesMutationResponse>;
  /** delete single row from the table: "addresses" */
  delete_addresses_by_pk?: Maybe<Addresses>;
  /** delete data from the table: "ads" */
  delete_ads?: Maybe<AdsMutationResponse>;
  /** delete single row from the table: "ads" */
  delete_ads_by_pk?: Maybe<Ads>;
  /** delete data from the table: "blacklisted_domains" */
  delete_blacklisted_domains?: Maybe<BlacklistedDomainsMutationResponse>;
  /** delete single row from the table: "blacklisted_domains" */
  delete_blacklisted_domains_by_pk?: Maybe<BlacklistedDomains>;
  /** delete data from the table: "blacklisted_urls" */
  delete_blacklisted_urls?: Maybe<BlacklistedUrlsMutationResponse>;
  /** delete single row from the table: "blacklisted_urls" */
  delete_blacklisted_urls_by_pk?: Maybe<BlacklistedUrls>;
  /** delete data from the table: "blocked_ips" */
  delete_blocked_ips?: Maybe<BlockedIpsMutationResponse>;
  /** delete single row from the table: "blocked_ips" */
  delete_blocked_ips_by_pk?: Maybe<BlockedIps>;
  /** delete data from the table: "bookmark_folders" */
  delete_bookmark_folders?: Maybe<BookmarkFoldersMutationResponse>;
  /** delete single row from the table: "bookmark_folders" */
  delete_bookmark_folders_by_pk?: Maybe<BookmarkFolders>;
  /** delete data from the table: "bookmarks" */
  delete_bookmarks?: Maybe<BookmarksMutationResponse>;
  /** delete single row from the table: "bookmarks" */
  delete_bookmarks_by_pk?: Maybe<Bookmarks>;
  /** delete data from the table: "business_domains" */
  delete_business_domains?: Maybe<BusinessDomainsMutationResponse>;
  /** delete single row from the table: "business_domains" */
  delete_business_domains_by_pk?: Maybe<BusinessDomains>;
  /** delete data from the table: "categories" */
  delete_categories?: Maybe<CategoriesMutationResponse>;
  /** delete single row from the table: "categories" */
  delete_categories_by_pk?: Maybe<Categories>;
  /** delete data from the table: "categorized_urls" */
  delete_categorized_urls?: Maybe<CategorizedUrlsMutationResponse>;
  /** delete single row from the table: "categorized_urls" */
  delete_categorized_urls_by_pk?: Maybe<CategorizedUrls>;
  /** delete data from the table: "circuit_breaker_states" */
  delete_circuit_breaker_states?: Maybe<CircuitBreakerStatesMutationResponse>;
  /** delete single row from the table: "circuit_breaker_states" */
  delete_circuit_breaker_states_by_pk?: Maybe<CircuitBreakerStates>;
  /** delete data from the table: "cities" */
  delete_cities?: Maybe<CitiesMutationResponse>;
  /** delete single row from the table: "cities" */
  delete_cities_by_pk?: Maybe<Cities>;
  /** delete data from the table: "comments" */
  delete_comments?: Maybe<CommentsMutationResponse>;
  /** delete single row from the table: "comments" */
  delete_comments_by_pk?: Maybe<Comments>;
  /** delete data from the table: "companies" */
  delete_companies?: Maybe<CompaniesMutationResponse>;
  /** delete single row from the table: "companies" */
  delete_companies_by_pk?: Maybe<Companies>;
  /** delete data from the table: "company_contacts" */
  delete_company_contacts?: Maybe<CompanyContactsMutationResponse>;
  /** delete single row from the table: "company_contacts" */
  delete_company_contacts_by_pk?: Maybe<CompanyContacts>;
  /** delete data from the table: "company_employees" */
  delete_company_employees?: Maybe<CompanyEmployeesMutationResponse>;
  /** delete single row from the table: "company_employees" */
  delete_company_employees_by_pk?: Maybe<CompanyEmployees>;
  /** delete data from the table: "company_extras" */
  delete_company_extras?: Maybe<CompanyExtrasMutationResponse>;
  /** delete single row from the table: "company_extras" */
  delete_company_extras_by_pk?: Maybe<CompanyExtras>;
  /** delete data from the table: "company_metrics" */
  delete_company_metrics?: Maybe<CompanyMetricsMutationResponse>;
  /** delete single row from the table: "company_metrics" */
  delete_company_metrics_by_pk?: Maybe<CompanyMetrics>;
  /** delete data from the table: "contacts" */
  delete_contacts?: Maybe<ContactsMutationResponse>;
  /** delete single row from the table: "contacts" */
  delete_contacts_by_pk?: Maybe<Contacts>;
  /** delete data from the table: "content_categories" */
  delete_content_categories?: Maybe<ContentCategoriesMutationResponse>;
  /** delete single row from the table: "content_categories" */
  delete_content_categories_by_pk?: Maybe<ContentCategories>;
  /** delete data from the table: "content_source_visits" */
  delete_content_source_visits?: Maybe<ContentSourceVisitsMutationResponse>;
  /** delete single row from the table: "content_source_visits" */
  delete_content_source_visits_by_pk?: Maybe<ContentSourceVisits>;
  /** delete data from the table: "content_sources" */
  delete_content_sources?: Maybe<ContentSourcesMutationResponse>;
  /** delete single row from the table: "content_sources" */
  delete_content_sources_by_pk?: Maybe<ContentSources>;
  /** delete data from the table: "content_statuses" */
  delete_content_statuses?: Maybe<ContentStatusesMutationResponse>;
  /** delete single row from the table: "content_statuses" */
  delete_content_statuses_by_pk?: Maybe<ContentStatuses>;
  /** delete data from the table: "content_tags" */
  delete_content_tags?: Maybe<ContentTagsMutationResponse>;
  /** delete single row from the table: "content_tags" */
  delete_content_tags_by_pk?: Maybe<ContentTags>;
  /** delete data from the table: "contents" */
  delete_contents?: Maybe<ContentsMutationResponse>;
  /** delete single row from the table: "contents" */
  delete_contents_by_pk?: Maybe<Contents>;
  /** delete data from the table: "countries" */
  delete_countries?: Maybe<CountriesMutationResponse>;
  /** delete single row from the table: "countries" */
  delete_countries_by_pk?: Maybe<Countries>;
  /** delete data from the table: "customer_payments" */
  delete_customer_payments?: Maybe<CustomerPaymentsMutationResponse>;
  /** delete single row from the table: "customer_payments" */
  delete_customer_payments_by_pk?: Maybe<CustomerPayments>;
  /** delete data from the table: "customer_processed_webhooks" */
  delete_customer_processed_webhooks?: Maybe<CustomerProcessedWebhooksMutationResponse>;
  /** delete single row from the table: "customer_processed_webhooks" */
  delete_customer_processed_webhooks_by_pk?: Maybe<CustomerProcessedWebhooks>;
  /** delete data from the table: "customer_refunds" */
  delete_customer_refunds?: Maybe<CustomerRefundsMutationResponse>;
  /** delete single row from the table: "customer_refunds" */
  delete_customer_refunds_by_pk?: Maybe<CustomerRefunds>;
  /** delete data from the table: "customer_subscription_plans" */
  delete_customer_subscription_plans?: Maybe<CustomerSubscriptionPlansMutationResponse>;
  /** delete single row from the table: "customer_subscription_plans" */
  delete_customer_subscription_plans_by_pk?: Maybe<CustomerSubscriptionPlans>;
  /** delete data from the table: "customer_subscriptions" */
  delete_customer_subscriptions?: Maybe<CustomerSubscriptionsMutationResponse>;
  /** delete single row from the table: "customer_subscriptions" */
  delete_customer_subscriptions_by_pk?: Maybe<CustomerSubscriptions>;
  /** delete data from the table: "embedding_reviews" */
  delete_embedding_reviews?: Maybe<EmbeddingReviewsMutationResponse>;
  /** delete single row from the table: "embedding_reviews" */
  delete_embedding_reviews_by_pk?: Maybe<EmbeddingReviews>;
  /** delete data from the table: "error_logs" */
  delete_error_logs?: Maybe<ErrorLogsMutationResponse>;
  /** delete single row from the table: "error_logs" */
  delete_error_logs_by_pk?: Maybe<ErrorLogs>;
  /** delete data from the table: "feature_requests" */
  delete_feature_requests?: Maybe<FeatureRequestsMutationResponse>;
  /** delete single row from the table: "feature_requests" */
  delete_feature_requests_by_pk?: Maybe<FeatureRequests>;
  /** delete data from the table: "feature_votes" */
  delete_feature_votes?: Maybe<FeatureVotesMutationResponse>;
  /** delete single row from the table: "feature_votes" */
  delete_feature_votes_by_pk?: Maybe<FeatureVotes>;
  /** delete data from the table: "feed_categories" */
  delete_feed_categories?: Maybe<FeedCategoriesMutationResponse>;
  /** delete single row from the table: "feed_categories" */
  delete_feed_categories_by_pk?: Maybe<FeedCategories>;
  /** delete data from the table: "feed_sources" */
  delete_feed_sources?: Maybe<FeedSourcesMutationResponse>;
  /** delete single row from the table: "feed_sources" */
  delete_feed_sources_by_pk?: Maybe<FeedSources>;
  /** delete data from the table: "feedbacks" */
  delete_feedbacks?: Maybe<FeedbacksMutationResponse>;
  /** delete single row from the table: "feedbacks" */
  delete_feedbacks_by_pk?: Maybe<Feedbacks>;
  /** delete data from the table: "feeds" */
  delete_feeds?: Maybe<FeedsMutationResponse>;
  /** delete single row from the table: "feeds" */
  delete_feeds_by_pk?: Maybe<Feeds>;
  /** delete data from the table: "follows" */
  delete_follows?: Maybe<FollowsMutationResponse>;
  /** delete single row from the table: "follows" */
  delete_follows_by_pk?: Maybe<Follows>;
  /** delete data from the table: "metric_definitions" */
  delete_metric_definitions?: Maybe<MetricDefinitionsMutationResponse>;
  /** delete single row from the table: "metric_definitions" */
  delete_metric_definitions_by_pk?: Maybe<MetricDefinitions>;
  /** delete data from the table: "news" */
  delete_news?: Maybe<NewsMutationResponse>;
  /** delete single row from the table: "news" */
  delete_news_by_pk?: Maybe<News>;
  /** delete data from the table: "news_summaries" */
  delete_news_summaries?: Maybe<NewsSummariesMutationResponse>;
  /** delete single row from the table: "news_summaries" */
  delete_news_summaries_by_pk?: Maybe<NewsSummaries>;
  /** delete data from the table: "news_tags" */
  delete_news_tags?: Maybe<NewsTagsMutationResponse>;
  /** delete single row from the table: "news_tags" */
  delete_news_tags_by_pk?: Maybe<NewsTags>;
  /** delete data from the table: "newsletters" */
  delete_newsletters?: Maybe<NewslettersMutationResponse>;
  /** delete single row from the table: "newsletters" */
  delete_newsletters_by_pk?: Maybe<Newsletters>;
  /** delete data from the table: "payment_providers" */
  delete_payment_providers?: Maybe<PaymentProvidersMutationResponse>;
  /** delete single row from the table: "payment_providers" */
  delete_payment_providers_by_pk?: Maybe<PaymentProviders>;
  /** delete data from the table: "plan_permissions" */
  delete_plan_permissions?: Maybe<PlanPermissionsMutationResponse>;
  /** delete single row from the table: "plan_permissions" */
  delete_plan_permissions_by_pk?: Maybe<PlanPermissions>;
  /** delete data from the table: "recent_errors" */
  delete_recent_errors?: Maybe<RecentErrorsMutationResponse>;
  /** delete data from the table: "referrals" */
  delete_referrals?: Maybe<ReferralsMutationResponse>;
  /** delete single row from the table: "referrals" */
  delete_referrals_by_pk?: Maybe<Referrals>;
  /** delete data from the table: "referrer_blocks" */
  delete_referrer_blocks?: Maybe<ReferrerBlocksMutationResponse>;
  /** delete single row from the table: "referrer_blocks" */
  delete_referrer_blocks_by_pk?: Maybe<ReferrerBlocks>;
  /** delete data from the table: "research" */
  delete_research?: Maybe<ResearchMutationResponse>;
  /** delete single row from the table: "research" */
  delete_research_by_pk?: Maybe<Research>;
  /** delete data from the table: "research_embeddings" */
  delete_research_embeddings?: Maybe<ResearchEmbeddingsMutationResponse>;
  /** delete single row from the table: "research_embeddings" */
  delete_research_embeddings_by_pk?: Maybe<ResearchEmbeddings>;
  /** delete data from the table: "responses" */
  delete_responses?: Maybe<ResponsesMutationResponse>;
  /** delete single row from the table: "responses" */
  delete_responses_by_pk?: Maybe<Responses>;
  /** delete data from the table: "role_hierarchy" */
  delete_role_hierarchy?: Maybe<RoleHierarchyMutationResponse>;
  /** delete single row from the table: "role_hierarchy" */
  delete_role_hierarchy_by_pk?: Maybe<RoleHierarchy>;
  /** delete data from the table: "role_permissions" */
  delete_role_permissions?: Maybe<RolePermissionsMutationResponse>;
  /** delete single row from the table: "role_permissions" */
  delete_role_permissions_by_pk?: Maybe<RolePermissions>;
  /** delete data from the table: "role_permissions_materialized" */
  delete_role_permissions_materialized?: Maybe<RolePermissionsMaterializedMutationResponse>;
  /** delete single row from the table: "role_permissions_materialized" */
  delete_role_permissions_materialized_by_pk?: Maybe<RolePermissionsMaterialized>;
  /** delete data from the table: "scoring_weights" */
  delete_scoring_weights?: Maybe<ScoringWeightsMutationResponse>;
  /** delete single row from the table: "scoring_weights" */
  delete_scoring_weights_by_pk?: Maybe<ScoringWeights>;
  /** delete data from the table: "searches" */
  delete_searches?: Maybe<SearchesMutationResponse>;
  /** delete single row from the table: "searches" */
  delete_searches_by_pk?: Maybe<Searches>;
  /** delete data from the table: "social_media" */
  delete_social_media?: Maybe<SocialMediaMutationResponse>;
  /** delete single row from the table: "social_media" */
  delete_social_media_by_pk?: Maybe<SocialMedia>;
  /** delete data from the table: "spider_metrics" */
  delete_spider_metrics?: Maybe<SpiderMetricsMutationResponse>;
  /** delete single row from the table: "spider_metrics" */
  delete_spider_metrics_by_pk?: Maybe<SpiderMetrics>;
  /** delete data from the table: "strapi_migrations" */
  delete_strapi_migrations?: Maybe<StrapiMigrationsMutationResponse>;
  /** delete single row from the table: "strapi_migrations" */
  delete_strapi_migrations_by_pk?: Maybe<StrapiMigrations>;
  /** delete data from the table: "strapi_migrations_internal" */
  delete_strapi_migrations_internal?: Maybe<StrapiMigrationsInternalMutationResponse>;
  /** delete single row from the table: "strapi_migrations_internal" */
  delete_strapi_migrations_internal_by_pk?: Maybe<StrapiMigrationsInternal>;
  /** delete data from the table: "table_maintenance_log" */
  delete_table_maintenance_log?: Maybe<TableMaintenanceLogMutationResponse>;
  /** delete single row from the table: "table_maintenance_log" */
  delete_table_maintenance_log_by_pk?: Maybe<TableMaintenanceLog>;
  /** delete data from the table: "table_query_performance" */
  delete_table_query_performance?: Maybe<TableQueryPerformanceMutationResponse>;
  /** delete data from the table: "table_sequence_usage" */
  delete_table_sequence_usage?: Maybe<TableSequenceUsageMutationResponse>;
  /** delete data from the table: "table_statistics" */
  delete_table_statistics?: Maybe<TableStatisticsMutationResponse>;
  /** delete single row from the table: "table_statistics" */
  delete_table_statistics_by_pk?: Maybe<TableStatistics>;
  /** delete data from the table: "tags" */
  delete_tags?: Maybe<TagsMutationResponse>;
  /** delete single row from the table: "tags" */
  delete_tags_by_pk?: Maybe<Tags>;
  /** delete data from the table: "user_metrics" */
  delete_user_metrics?: Maybe<UserMetricsMutationResponse>;
  /** delete single row from the table: "user_metrics" */
  delete_user_metrics_by_pk?: Maybe<UserMetrics>;
  /** delete data from the table: "user_profiles" */
  delete_user_profiles?: Maybe<UserProfilesMutationResponse>;
  /** delete single row from the table: "user_profiles" */
  delete_user_profiles_by_pk?: Maybe<UserProfiles>;
  /** delete data from the table: "votes" */
  delete_votes?: Maybe<VotesMutationResponse>;
  /** delete single row from the table: "votes" */
  delete_votes_by_pk?: Maybe<Votes>;
  /** delete data from the table: "workflows" */
  delete_workflows?: Maybe<WorkflowsMutationResponse>;
  /** delete single row from the table: "workflows" */
  delete_workflows_by_pk?: Maybe<Workflows>;
  /** insert data into the table: "ad_daily_metrics" */
  insert_ad_daily_metrics?: Maybe<AdDailyMetricsMutationResponse>;
  /** insert a single row into the table: "ad_daily_metrics" */
  insert_ad_daily_metrics_one?: Maybe<AdDailyMetrics>;
  /** insert data into the table: "ad_packages" */
  insert_ad_packages?: Maybe<AdPackagesMutationResponse>;
  /** insert a single row into the table: "ad_packages" */
  insert_ad_packages_one?: Maybe<AdPackages>;
  /** insert data into the table: "ad_variants" */
  insert_ad_variants?: Maybe<AdVariantsMutationResponse>;
  /** insert a single row into the table: "ad_variants" */
  insert_ad_variants_one?: Maybe<AdVariants>;
  /** insert data into the table: "addresses" */
  insert_addresses?: Maybe<AddressesMutationResponse>;
  /** insert a single row into the table: "addresses" */
  insert_addresses_one?: Maybe<Addresses>;
  /** insert data into the table: "ads" */
  insert_ads?: Maybe<AdsMutationResponse>;
  /** insert a single row into the table: "ads" */
  insert_ads_one?: Maybe<Ads>;
  /** insert data into the table: "blacklisted_domains" */
  insert_blacklisted_domains?: Maybe<BlacklistedDomainsMutationResponse>;
  /** insert a single row into the table: "blacklisted_domains" */
  insert_blacklisted_domains_one?: Maybe<BlacklistedDomains>;
  /** insert data into the table: "blacklisted_urls" */
  insert_blacklisted_urls?: Maybe<BlacklistedUrlsMutationResponse>;
  /** insert a single row into the table: "blacklisted_urls" */
  insert_blacklisted_urls_one?: Maybe<BlacklistedUrls>;
  /** insert data into the table: "blocked_ips" */
  insert_blocked_ips?: Maybe<BlockedIpsMutationResponse>;
  /** insert a single row into the table: "blocked_ips" */
  insert_blocked_ips_one?: Maybe<BlockedIps>;
  /** insert data into the table: "bookmark_folders" */
  insert_bookmark_folders?: Maybe<BookmarkFoldersMutationResponse>;
  /** insert a single row into the table: "bookmark_folders" */
  insert_bookmark_folders_one?: Maybe<BookmarkFolders>;
  /** insert data into the table: "bookmarks" */
  insert_bookmarks?: Maybe<BookmarksMutationResponse>;
  /** insert a single row into the table: "bookmarks" */
  insert_bookmarks_one?: Maybe<Bookmarks>;
  /** insert data into the table: "business_domains" */
  insert_business_domains?: Maybe<BusinessDomainsMutationResponse>;
  /** insert a single row into the table: "business_domains" */
  insert_business_domains_one?: Maybe<BusinessDomains>;
  /** insert data into the table: "categories" */
  insert_categories?: Maybe<CategoriesMutationResponse>;
  /** insert a single row into the table: "categories" */
  insert_categories_one?: Maybe<Categories>;
  /** insert data into the table: "categorized_urls" */
  insert_categorized_urls?: Maybe<CategorizedUrlsMutationResponse>;
  /** insert a single row into the table: "categorized_urls" */
  insert_categorized_urls_one?: Maybe<CategorizedUrls>;
  /** insert data into the table: "circuit_breaker_states" */
  insert_circuit_breaker_states?: Maybe<CircuitBreakerStatesMutationResponse>;
  /** insert a single row into the table: "circuit_breaker_states" */
  insert_circuit_breaker_states_one?: Maybe<CircuitBreakerStates>;
  /** insert data into the table: "cities" */
  insert_cities?: Maybe<CitiesMutationResponse>;
  /** insert a single row into the table: "cities" */
  insert_cities_one?: Maybe<Cities>;
  /** insert data into the table: "comments" */
  insert_comments?: Maybe<CommentsMutationResponse>;
  /** insert a single row into the table: "comments" */
  insert_comments_one?: Maybe<Comments>;
  /** insert data into the table: "companies" */
  insert_companies?: Maybe<CompaniesMutationResponse>;
  /** insert a single row into the table: "companies" */
  insert_companies_one?: Maybe<Companies>;
  /** insert data into the table: "company_contacts" */
  insert_company_contacts?: Maybe<CompanyContactsMutationResponse>;
  /** insert a single row into the table: "company_contacts" */
  insert_company_contacts_one?: Maybe<CompanyContacts>;
  /** insert data into the table: "company_employees" */
  insert_company_employees?: Maybe<CompanyEmployeesMutationResponse>;
  /** insert a single row into the table: "company_employees" */
  insert_company_employees_one?: Maybe<CompanyEmployees>;
  /** insert data into the table: "company_extras" */
  insert_company_extras?: Maybe<CompanyExtrasMutationResponse>;
  /** insert a single row into the table: "company_extras" */
  insert_company_extras_one?: Maybe<CompanyExtras>;
  /** insert data into the table: "company_metrics" */
  insert_company_metrics?: Maybe<CompanyMetricsMutationResponse>;
  /** insert a single row into the table: "company_metrics" */
  insert_company_metrics_one?: Maybe<CompanyMetrics>;
  /** insert data into the table: "contacts" */
  insert_contacts?: Maybe<ContactsMutationResponse>;
  /** insert a single row into the table: "contacts" */
  insert_contacts_one?: Maybe<Contacts>;
  /** insert data into the table: "content_categories" */
  insert_content_categories?: Maybe<ContentCategoriesMutationResponse>;
  /** insert a single row into the table: "content_categories" */
  insert_content_categories_one?: Maybe<ContentCategories>;
  /** insert data into the table: "content_source_visits" */
  insert_content_source_visits?: Maybe<ContentSourceVisitsMutationResponse>;
  /** insert a single row into the table: "content_source_visits" */
  insert_content_source_visits_one?: Maybe<ContentSourceVisits>;
  /** insert data into the table: "content_sources" */
  insert_content_sources?: Maybe<ContentSourcesMutationResponse>;
  /** insert a single row into the table: "content_sources" */
  insert_content_sources_one?: Maybe<ContentSources>;
  /** insert data into the table: "content_statuses" */
  insert_content_statuses?: Maybe<ContentStatusesMutationResponse>;
  /** insert a single row into the table: "content_statuses" */
  insert_content_statuses_one?: Maybe<ContentStatuses>;
  /** insert data into the table: "content_tags" */
  insert_content_tags?: Maybe<ContentTagsMutationResponse>;
  /** insert a single row into the table: "content_tags" */
  insert_content_tags_one?: Maybe<ContentTags>;
  /** insert data into the table: "contents" */
  insert_contents?: Maybe<ContentsMutationResponse>;
  /** insert a single row into the table: "contents" */
  insert_contents_one?: Maybe<Contents>;
  /** insert data into the table: "countries" */
  insert_countries?: Maybe<CountriesMutationResponse>;
  /** insert a single row into the table: "countries" */
  insert_countries_one?: Maybe<Countries>;
  /** insert data into the table: "customer_payments" */
  insert_customer_payments?: Maybe<CustomerPaymentsMutationResponse>;
  /** insert a single row into the table: "customer_payments" */
  insert_customer_payments_one?: Maybe<CustomerPayments>;
  /** insert data into the table: "customer_processed_webhooks" */
  insert_customer_processed_webhooks?: Maybe<CustomerProcessedWebhooksMutationResponse>;
  /** insert a single row into the table: "customer_processed_webhooks" */
  insert_customer_processed_webhooks_one?: Maybe<CustomerProcessedWebhooks>;
  /** insert data into the table: "customer_refunds" */
  insert_customer_refunds?: Maybe<CustomerRefundsMutationResponse>;
  /** insert a single row into the table: "customer_refunds" */
  insert_customer_refunds_one?: Maybe<CustomerRefunds>;
  /** insert data into the table: "customer_subscription_plans" */
  insert_customer_subscription_plans?: Maybe<CustomerSubscriptionPlansMutationResponse>;
  /** insert a single row into the table: "customer_subscription_plans" */
  insert_customer_subscription_plans_one?: Maybe<CustomerSubscriptionPlans>;
  /** insert data into the table: "customer_subscriptions" */
  insert_customer_subscriptions?: Maybe<CustomerSubscriptionsMutationResponse>;
  /** insert a single row into the table: "customer_subscriptions" */
  insert_customer_subscriptions_one?: Maybe<CustomerSubscriptions>;
  /** insert data into the table: "embedding_reviews" */
  insert_embedding_reviews?: Maybe<EmbeddingReviewsMutationResponse>;
  /** insert a single row into the table: "embedding_reviews" */
  insert_embedding_reviews_one?: Maybe<EmbeddingReviews>;
  /** insert data into the table: "error_logs" */
  insert_error_logs?: Maybe<ErrorLogsMutationResponse>;
  /** insert a single row into the table: "error_logs" */
  insert_error_logs_one?: Maybe<ErrorLogs>;
  /** insert data into the table: "feature_requests" */
  insert_feature_requests?: Maybe<FeatureRequestsMutationResponse>;
  /** insert a single row into the table: "feature_requests" */
  insert_feature_requests_one?: Maybe<FeatureRequests>;
  /** insert data into the table: "feature_votes" */
  insert_feature_votes?: Maybe<FeatureVotesMutationResponse>;
  /** insert a single row into the table: "feature_votes" */
  insert_feature_votes_one?: Maybe<FeatureVotes>;
  /** insert data into the table: "feed_categories" */
  insert_feed_categories?: Maybe<FeedCategoriesMutationResponse>;
  /** insert a single row into the table: "feed_categories" */
  insert_feed_categories_one?: Maybe<FeedCategories>;
  /** insert data into the table: "feed_sources" */
  insert_feed_sources?: Maybe<FeedSourcesMutationResponse>;
  /** insert a single row into the table: "feed_sources" */
  insert_feed_sources_one?: Maybe<FeedSources>;
  /** insert data into the table: "feedbacks" */
  insert_feedbacks?: Maybe<FeedbacksMutationResponse>;
  /** insert a single row into the table: "feedbacks" */
  insert_feedbacks_one?: Maybe<Feedbacks>;
  /** insert data into the table: "feeds" */
  insert_feeds?: Maybe<FeedsMutationResponse>;
  /** insert a single row into the table: "feeds" */
  insert_feeds_one?: Maybe<Feeds>;
  /** insert data into the table: "follows" */
  insert_follows?: Maybe<FollowsMutationResponse>;
  /** insert a single row into the table: "follows" */
  insert_follows_one?: Maybe<Follows>;
  /** insert data into the table: "metric_definitions" */
  insert_metric_definitions?: Maybe<MetricDefinitionsMutationResponse>;
  /** insert a single row into the table: "metric_definitions" */
  insert_metric_definitions_one?: Maybe<MetricDefinitions>;
  /** insert data into the table: "news" */
  insert_news?: Maybe<NewsMutationResponse>;
  /** insert a single row into the table: "news" */
  insert_news_one?: Maybe<News>;
  /** insert data into the table: "news_summaries" */
  insert_news_summaries?: Maybe<NewsSummariesMutationResponse>;
  /** insert a single row into the table: "news_summaries" */
  insert_news_summaries_one?: Maybe<NewsSummaries>;
  /** insert data into the table: "news_tags" */
  insert_news_tags?: Maybe<NewsTagsMutationResponse>;
  /** insert a single row into the table: "news_tags" */
  insert_news_tags_one?: Maybe<NewsTags>;
  /** insert data into the table: "newsletters" */
  insert_newsletters?: Maybe<NewslettersMutationResponse>;
  /** insert a single row into the table: "newsletters" */
  insert_newsletters_one?: Maybe<Newsletters>;
  /** insert data into the table: "payment_providers" */
  insert_payment_providers?: Maybe<PaymentProvidersMutationResponse>;
  /** insert a single row into the table: "payment_providers" */
  insert_payment_providers_one?: Maybe<PaymentProviders>;
  /** insert data into the table: "plan_permissions" */
  insert_plan_permissions?: Maybe<PlanPermissionsMutationResponse>;
  /** insert a single row into the table: "plan_permissions" */
  insert_plan_permissions_one?: Maybe<PlanPermissions>;
  /** insert data into the table: "recent_errors" */
  insert_recent_errors?: Maybe<RecentErrorsMutationResponse>;
  /** insert a single row into the table: "recent_errors" */
  insert_recent_errors_one?: Maybe<RecentErrors>;
  /** insert data into the table: "referrals" */
  insert_referrals?: Maybe<ReferralsMutationResponse>;
  /** insert a single row into the table: "referrals" */
  insert_referrals_one?: Maybe<Referrals>;
  /** insert data into the table: "referrer_blocks" */
  insert_referrer_blocks?: Maybe<ReferrerBlocksMutationResponse>;
  /** insert a single row into the table: "referrer_blocks" */
  insert_referrer_blocks_one?: Maybe<ReferrerBlocks>;
  /** insert data into the table: "research" */
  insert_research?: Maybe<ResearchMutationResponse>;
  /** insert data into the table: "research_embeddings" */
  insert_research_embeddings?: Maybe<ResearchEmbeddingsMutationResponse>;
  /** insert a single row into the table: "research_embeddings" */
  insert_research_embeddings_one?: Maybe<ResearchEmbeddings>;
  /** insert a single row into the table: "research" */
  insert_research_one?: Maybe<Research>;
  /** insert data into the table: "responses" */
  insert_responses?: Maybe<ResponsesMutationResponse>;
  /** insert a single row into the table: "responses" */
  insert_responses_one?: Maybe<Responses>;
  /** insert data into the table: "role_hierarchy" */
  insert_role_hierarchy?: Maybe<RoleHierarchyMutationResponse>;
  /** insert a single row into the table: "role_hierarchy" */
  insert_role_hierarchy_one?: Maybe<RoleHierarchy>;
  /** insert data into the table: "role_permissions" */
  insert_role_permissions?: Maybe<RolePermissionsMutationResponse>;
  /** insert data into the table: "role_permissions_materialized" */
  insert_role_permissions_materialized?: Maybe<RolePermissionsMaterializedMutationResponse>;
  /** insert a single row into the table: "role_permissions_materialized" */
  insert_role_permissions_materialized_one?: Maybe<RolePermissionsMaterialized>;
  /** insert a single row into the table: "role_permissions" */
  insert_role_permissions_one?: Maybe<RolePermissions>;
  /** insert data into the table: "scoring_weights" */
  insert_scoring_weights?: Maybe<ScoringWeightsMutationResponse>;
  /** insert a single row into the table: "scoring_weights" */
  insert_scoring_weights_one?: Maybe<ScoringWeights>;
  /** insert data into the table: "searches" */
  insert_searches?: Maybe<SearchesMutationResponse>;
  /** insert a single row into the table: "searches" */
  insert_searches_one?: Maybe<Searches>;
  /** insert data into the table: "social_media" */
  insert_social_media?: Maybe<SocialMediaMutationResponse>;
  /** insert a single row into the table: "social_media" */
  insert_social_media_one?: Maybe<SocialMedia>;
  /** insert data into the table: "spider_metrics" */
  insert_spider_metrics?: Maybe<SpiderMetricsMutationResponse>;
  /** insert a single row into the table: "spider_metrics" */
  insert_spider_metrics_one?: Maybe<SpiderMetrics>;
  /** insert data into the table: "strapi_migrations" */
  insert_strapi_migrations?: Maybe<StrapiMigrationsMutationResponse>;
  /** insert data into the table: "strapi_migrations_internal" */
  insert_strapi_migrations_internal?: Maybe<StrapiMigrationsInternalMutationResponse>;
  /** insert a single row into the table: "strapi_migrations_internal" */
  insert_strapi_migrations_internal_one?: Maybe<StrapiMigrationsInternal>;
  /** insert a single row into the table: "strapi_migrations" */
  insert_strapi_migrations_one?: Maybe<StrapiMigrations>;
  /** insert data into the table: "table_maintenance_log" */
  insert_table_maintenance_log?: Maybe<TableMaintenanceLogMutationResponse>;
  /** insert a single row into the table: "table_maintenance_log" */
  insert_table_maintenance_log_one?: Maybe<TableMaintenanceLog>;
  /** insert data into the table: "table_query_performance" */
  insert_table_query_performance?: Maybe<TableQueryPerformanceMutationResponse>;
  /** insert a single row into the table: "table_query_performance" */
  insert_table_query_performance_one?: Maybe<TableQueryPerformance>;
  /** insert data into the table: "table_sequence_usage" */
  insert_table_sequence_usage?: Maybe<TableSequenceUsageMutationResponse>;
  /** insert a single row into the table: "table_sequence_usage" */
  insert_table_sequence_usage_one?: Maybe<TableSequenceUsage>;
  /** insert data into the table: "table_statistics" */
  insert_table_statistics?: Maybe<TableStatisticsMutationResponse>;
  /** insert a single row into the table: "table_statistics" */
  insert_table_statistics_one?: Maybe<TableStatistics>;
  /** insert data into the table: "tags" */
  insert_tags?: Maybe<TagsMutationResponse>;
  /** insert a single row into the table: "tags" */
  insert_tags_one?: Maybe<Tags>;
  /** insert data into the table: "user_metrics" */
  insert_user_metrics?: Maybe<UserMetricsMutationResponse>;
  /** insert a single row into the table: "user_metrics" */
  insert_user_metrics_one?: Maybe<UserMetrics>;
  /** insert data into the table: "user_profiles" */
  insert_user_profiles?: Maybe<UserProfilesMutationResponse>;
  /** insert a single row into the table: "user_profiles" */
  insert_user_profiles_one?: Maybe<UserProfiles>;
  /** insert data into the table: "votes" */
  insert_votes?: Maybe<VotesMutationResponse>;
  /** insert a single row into the table: "votes" */
  insert_votes_one?: Maybe<Votes>;
  /** insert data into the table: "workflows" */
  insert_workflows?: Maybe<WorkflowsMutationResponse>;
  /** insert a single row into the table: "workflows" */
  insert_workflows_one?: Maybe<Workflows>;
  /** execute VOLATILE function "match_research" which returns "research_embeddings" */
  match_research: Array<ResearchEmbeddings>;
  /** update data of the table: "ad_daily_metrics" */
  update_ad_daily_metrics?: Maybe<AdDailyMetricsMutationResponse>;
  /** update single row of the table: "ad_daily_metrics" */
  update_ad_daily_metrics_by_pk?: Maybe<AdDailyMetrics>;
  /** update multiples rows of table: "ad_daily_metrics" */
  update_ad_daily_metrics_many?: Maybe<
    Array<Maybe<AdDailyMetricsMutationResponse>>
  >;
  /** update data of the table: "ad_packages" */
  update_ad_packages?: Maybe<AdPackagesMutationResponse>;
  /** update single row of the table: "ad_packages" */
  update_ad_packages_by_pk?: Maybe<AdPackages>;
  /** update multiples rows of table: "ad_packages" */
  update_ad_packages_many?: Maybe<Array<Maybe<AdPackagesMutationResponse>>>;
  /** update data of the table: "ad_variants" */
  update_ad_variants?: Maybe<AdVariantsMutationResponse>;
  /** update single row of the table: "ad_variants" */
  update_ad_variants_by_pk?: Maybe<AdVariants>;
  /** update multiples rows of table: "ad_variants" */
  update_ad_variants_many?: Maybe<Array<Maybe<AdVariantsMutationResponse>>>;
  /** update data of the table: "addresses" */
  update_addresses?: Maybe<AddressesMutationResponse>;
  /** update single row of the table: "addresses" */
  update_addresses_by_pk?: Maybe<Addresses>;
  /** update multiples rows of table: "addresses" */
  update_addresses_many?: Maybe<Array<Maybe<AddressesMutationResponse>>>;
  /** update data of the table: "ads" */
  update_ads?: Maybe<AdsMutationResponse>;
  /** update single row of the table: "ads" */
  update_ads_by_pk?: Maybe<Ads>;
  /** update multiples rows of table: "ads" */
  update_ads_many?: Maybe<Array<Maybe<AdsMutationResponse>>>;
  /** update data of the table: "blacklisted_domains" */
  update_blacklisted_domains?: Maybe<BlacklistedDomainsMutationResponse>;
  /** update single row of the table: "blacklisted_domains" */
  update_blacklisted_domains_by_pk?: Maybe<BlacklistedDomains>;
  /** update multiples rows of table: "blacklisted_domains" */
  update_blacklisted_domains_many?: Maybe<
    Array<Maybe<BlacklistedDomainsMutationResponse>>
  >;
  /** update data of the table: "blacklisted_urls" */
  update_blacklisted_urls?: Maybe<BlacklistedUrlsMutationResponse>;
  /** update single row of the table: "blacklisted_urls" */
  update_blacklisted_urls_by_pk?: Maybe<BlacklistedUrls>;
  /** update multiples rows of table: "blacklisted_urls" */
  update_blacklisted_urls_many?: Maybe<
    Array<Maybe<BlacklistedUrlsMutationResponse>>
  >;
  /** update data of the table: "blocked_ips" */
  update_blocked_ips?: Maybe<BlockedIpsMutationResponse>;
  /** update single row of the table: "blocked_ips" */
  update_blocked_ips_by_pk?: Maybe<BlockedIps>;
  /** update multiples rows of table: "blocked_ips" */
  update_blocked_ips_many?: Maybe<Array<Maybe<BlockedIpsMutationResponse>>>;
  /** update data of the table: "bookmark_folders" */
  update_bookmark_folders?: Maybe<BookmarkFoldersMutationResponse>;
  /** update single row of the table: "bookmark_folders" */
  update_bookmark_folders_by_pk?: Maybe<BookmarkFolders>;
  /** update multiples rows of table: "bookmark_folders" */
  update_bookmark_folders_many?: Maybe<
    Array<Maybe<BookmarkFoldersMutationResponse>>
  >;
  /** update data of the table: "bookmarks" */
  update_bookmarks?: Maybe<BookmarksMutationResponse>;
  /** update single row of the table: "bookmarks" */
  update_bookmarks_by_pk?: Maybe<Bookmarks>;
  /** update multiples rows of table: "bookmarks" */
  update_bookmarks_many?: Maybe<Array<Maybe<BookmarksMutationResponse>>>;
  /** update data of the table: "business_domains" */
  update_business_domains?: Maybe<BusinessDomainsMutationResponse>;
  /** update single row of the table: "business_domains" */
  update_business_domains_by_pk?: Maybe<BusinessDomains>;
  /** update multiples rows of table: "business_domains" */
  update_business_domains_many?: Maybe<
    Array<Maybe<BusinessDomainsMutationResponse>>
  >;
  /** update data of the table: "categories" */
  update_categories?: Maybe<CategoriesMutationResponse>;
  /** update single row of the table: "categories" */
  update_categories_by_pk?: Maybe<Categories>;
  /** update multiples rows of table: "categories" */
  update_categories_many?: Maybe<Array<Maybe<CategoriesMutationResponse>>>;
  /** update data of the table: "categorized_urls" */
  update_categorized_urls?: Maybe<CategorizedUrlsMutationResponse>;
  /** update single row of the table: "categorized_urls" */
  update_categorized_urls_by_pk?: Maybe<CategorizedUrls>;
  /** update multiples rows of table: "categorized_urls" */
  update_categorized_urls_many?: Maybe<
    Array<Maybe<CategorizedUrlsMutationResponse>>
  >;
  /** update data of the table: "circuit_breaker_states" */
  update_circuit_breaker_states?: Maybe<CircuitBreakerStatesMutationResponse>;
  /** update single row of the table: "circuit_breaker_states" */
  update_circuit_breaker_states_by_pk?: Maybe<CircuitBreakerStates>;
  /** update multiples rows of table: "circuit_breaker_states" */
  update_circuit_breaker_states_many?: Maybe<
    Array<Maybe<CircuitBreakerStatesMutationResponse>>
  >;
  /** update data of the table: "cities" */
  update_cities?: Maybe<CitiesMutationResponse>;
  /** update single row of the table: "cities" */
  update_cities_by_pk?: Maybe<Cities>;
  /** update multiples rows of table: "cities" */
  update_cities_many?: Maybe<Array<Maybe<CitiesMutationResponse>>>;
  /** update data of the table: "comments" */
  update_comments?: Maybe<CommentsMutationResponse>;
  /** update single row of the table: "comments" */
  update_comments_by_pk?: Maybe<Comments>;
  /** update multiples rows of table: "comments" */
  update_comments_many?: Maybe<Array<Maybe<CommentsMutationResponse>>>;
  /** update data of the table: "companies" */
  update_companies?: Maybe<CompaniesMutationResponse>;
  /** update single row of the table: "companies" */
  update_companies_by_pk?: Maybe<Companies>;
  /** update multiples rows of table: "companies" */
  update_companies_many?: Maybe<Array<Maybe<CompaniesMutationResponse>>>;
  /** update data of the table: "company_contacts" */
  update_company_contacts?: Maybe<CompanyContactsMutationResponse>;
  /** update single row of the table: "company_contacts" */
  update_company_contacts_by_pk?: Maybe<CompanyContacts>;
  /** update multiples rows of table: "company_contacts" */
  update_company_contacts_many?: Maybe<
    Array<Maybe<CompanyContactsMutationResponse>>
  >;
  /** update data of the table: "company_employees" */
  update_company_employees?: Maybe<CompanyEmployeesMutationResponse>;
  /** update single row of the table: "company_employees" */
  update_company_employees_by_pk?: Maybe<CompanyEmployees>;
  /** update multiples rows of table: "company_employees" */
  update_company_employees_many?: Maybe<
    Array<Maybe<CompanyEmployeesMutationResponse>>
  >;
  /** update data of the table: "company_extras" */
  update_company_extras?: Maybe<CompanyExtrasMutationResponse>;
  /** update single row of the table: "company_extras" */
  update_company_extras_by_pk?: Maybe<CompanyExtras>;
  /** update multiples rows of table: "company_extras" */
  update_company_extras_many?: Maybe<
    Array<Maybe<CompanyExtrasMutationResponse>>
  >;
  /** update data of the table: "company_metrics" */
  update_company_metrics?: Maybe<CompanyMetricsMutationResponse>;
  /** update single row of the table: "company_metrics" */
  update_company_metrics_by_pk?: Maybe<CompanyMetrics>;
  /** update multiples rows of table: "company_metrics" */
  update_company_metrics_many?: Maybe<
    Array<Maybe<CompanyMetricsMutationResponse>>
  >;
  /** update data of the table: "contacts" */
  update_contacts?: Maybe<ContactsMutationResponse>;
  /** update single row of the table: "contacts" */
  update_contacts_by_pk?: Maybe<Contacts>;
  /** update multiples rows of table: "contacts" */
  update_contacts_many?: Maybe<Array<Maybe<ContactsMutationResponse>>>;
  /** update data of the table: "content_categories" */
  update_content_categories?: Maybe<ContentCategoriesMutationResponse>;
  /** update single row of the table: "content_categories" */
  update_content_categories_by_pk?: Maybe<ContentCategories>;
  /** update multiples rows of table: "content_categories" */
  update_content_categories_many?: Maybe<
    Array<Maybe<ContentCategoriesMutationResponse>>
  >;
  /** update data of the table: "content_source_visits" */
  update_content_source_visits?: Maybe<ContentSourceVisitsMutationResponse>;
  /** update single row of the table: "content_source_visits" */
  update_content_source_visits_by_pk?: Maybe<ContentSourceVisits>;
  /** update multiples rows of table: "content_source_visits" */
  update_content_source_visits_many?: Maybe<
    Array<Maybe<ContentSourceVisitsMutationResponse>>
  >;
  /** update data of the table: "content_sources" */
  update_content_sources?: Maybe<ContentSourcesMutationResponse>;
  /** update single row of the table: "content_sources" */
  update_content_sources_by_pk?: Maybe<ContentSources>;
  /** update multiples rows of table: "content_sources" */
  update_content_sources_many?: Maybe<
    Array<Maybe<ContentSourcesMutationResponse>>
  >;
  /** update data of the table: "content_statuses" */
  update_content_statuses?: Maybe<ContentStatusesMutationResponse>;
  /** update single row of the table: "content_statuses" */
  update_content_statuses_by_pk?: Maybe<ContentStatuses>;
  /** update multiples rows of table: "content_statuses" */
  update_content_statuses_many?: Maybe<
    Array<Maybe<ContentStatusesMutationResponse>>
  >;
  /** update data of the table: "content_tags" */
  update_content_tags?: Maybe<ContentTagsMutationResponse>;
  /** update single row of the table: "content_tags" */
  update_content_tags_by_pk?: Maybe<ContentTags>;
  /** update multiples rows of table: "content_tags" */
  update_content_tags_many?: Maybe<Array<Maybe<ContentTagsMutationResponse>>>;
  /** update data of the table: "contents" */
  update_contents?: Maybe<ContentsMutationResponse>;
  /** update single row of the table: "contents" */
  update_contents_by_pk?: Maybe<Contents>;
  /** update multiples rows of table: "contents" */
  update_contents_many?: Maybe<Array<Maybe<ContentsMutationResponse>>>;
  /** update data of the table: "countries" */
  update_countries?: Maybe<CountriesMutationResponse>;
  /** update single row of the table: "countries" */
  update_countries_by_pk?: Maybe<Countries>;
  /** update multiples rows of table: "countries" */
  update_countries_many?: Maybe<Array<Maybe<CountriesMutationResponse>>>;
  /** update data of the table: "customer_payments" */
  update_customer_payments?: Maybe<CustomerPaymentsMutationResponse>;
  /** update single row of the table: "customer_payments" */
  update_customer_payments_by_pk?: Maybe<CustomerPayments>;
  /** update multiples rows of table: "customer_payments" */
  update_customer_payments_many?: Maybe<
    Array<Maybe<CustomerPaymentsMutationResponse>>
  >;
  /** update data of the table: "customer_processed_webhooks" */
  update_customer_processed_webhooks?: Maybe<CustomerProcessedWebhooksMutationResponse>;
  /** update single row of the table: "customer_processed_webhooks" */
  update_customer_processed_webhooks_by_pk?: Maybe<CustomerProcessedWebhooks>;
  /** update multiples rows of table: "customer_processed_webhooks" */
  update_customer_processed_webhooks_many?: Maybe<
    Array<Maybe<CustomerProcessedWebhooksMutationResponse>>
  >;
  /** update data of the table: "customer_refunds" */
  update_customer_refunds?: Maybe<CustomerRefundsMutationResponse>;
  /** update single row of the table: "customer_refunds" */
  update_customer_refunds_by_pk?: Maybe<CustomerRefunds>;
  /** update multiples rows of table: "customer_refunds" */
  update_customer_refunds_many?: Maybe<
    Array<Maybe<CustomerRefundsMutationResponse>>
  >;
  /** update data of the table: "customer_subscription_plans" */
  update_customer_subscription_plans?: Maybe<CustomerSubscriptionPlansMutationResponse>;
  /** update single row of the table: "customer_subscription_plans" */
  update_customer_subscription_plans_by_pk?: Maybe<CustomerSubscriptionPlans>;
  /** update multiples rows of table: "customer_subscription_plans" */
  update_customer_subscription_plans_many?: Maybe<
    Array<Maybe<CustomerSubscriptionPlansMutationResponse>>
  >;
  /** update data of the table: "customer_subscriptions" */
  update_customer_subscriptions?: Maybe<CustomerSubscriptionsMutationResponse>;
  /** update single row of the table: "customer_subscriptions" */
  update_customer_subscriptions_by_pk?: Maybe<CustomerSubscriptions>;
  /** update multiples rows of table: "customer_subscriptions" */
  update_customer_subscriptions_many?: Maybe<
    Array<Maybe<CustomerSubscriptionsMutationResponse>>
  >;
  /** update data of the table: "embedding_reviews" */
  update_embedding_reviews?: Maybe<EmbeddingReviewsMutationResponse>;
  /** update single row of the table: "embedding_reviews" */
  update_embedding_reviews_by_pk?: Maybe<EmbeddingReviews>;
  /** update multiples rows of table: "embedding_reviews" */
  update_embedding_reviews_many?: Maybe<
    Array<Maybe<EmbeddingReviewsMutationResponse>>
  >;
  /** update data of the table: "error_logs" */
  update_error_logs?: Maybe<ErrorLogsMutationResponse>;
  /** update single row of the table: "error_logs" */
  update_error_logs_by_pk?: Maybe<ErrorLogs>;
  /** update multiples rows of table: "error_logs" */
  update_error_logs_many?: Maybe<Array<Maybe<ErrorLogsMutationResponse>>>;
  /** update data of the table: "feature_requests" */
  update_feature_requests?: Maybe<FeatureRequestsMutationResponse>;
  /** update single row of the table: "feature_requests" */
  update_feature_requests_by_pk?: Maybe<FeatureRequests>;
  /** update multiples rows of table: "feature_requests" */
  update_feature_requests_many?: Maybe<
    Array<Maybe<FeatureRequestsMutationResponse>>
  >;
  /** update data of the table: "feature_votes" */
  update_feature_votes?: Maybe<FeatureVotesMutationResponse>;
  /** update single row of the table: "feature_votes" */
  update_feature_votes_by_pk?: Maybe<FeatureVotes>;
  /** update multiples rows of table: "feature_votes" */
  update_feature_votes_many?: Maybe<Array<Maybe<FeatureVotesMutationResponse>>>;
  /** update data of the table: "feed_categories" */
  update_feed_categories?: Maybe<FeedCategoriesMutationResponse>;
  /** update single row of the table: "feed_categories" */
  update_feed_categories_by_pk?: Maybe<FeedCategories>;
  /** update multiples rows of table: "feed_categories" */
  update_feed_categories_many?: Maybe<
    Array<Maybe<FeedCategoriesMutationResponse>>
  >;
  /** update data of the table: "feed_sources" */
  update_feed_sources?: Maybe<FeedSourcesMutationResponse>;
  /** update single row of the table: "feed_sources" */
  update_feed_sources_by_pk?: Maybe<FeedSources>;
  /** update multiples rows of table: "feed_sources" */
  update_feed_sources_many?: Maybe<Array<Maybe<FeedSourcesMutationResponse>>>;
  /** update data of the table: "feedbacks" */
  update_feedbacks?: Maybe<FeedbacksMutationResponse>;
  /** update single row of the table: "feedbacks" */
  update_feedbacks_by_pk?: Maybe<Feedbacks>;
  /** update multiples rows of table: "feedbacks" */
  update_feedbacks_many?: Maybe<Array<Maybe<FeedbacksMutationResponse>>>;
  /** update data of the table: "feeds" */
  update_feeds?: Maybe<FeedsMutationResponse>;
  /** update single row of the table: "feeds" */
  update_feeds_by_pk?: Maybe<Feeds>;
  /** update multiples rows of table: "feeds" */
  update_feeds_many?: Maybe<Array<Maybe<FeedsMutationResponse>>>;
  /** update data of the table: "follows" */
  update_follows?: Maybe<FollowsMutationResponse>;
  /** update single row of the table: "follows" */
  update_follows_by_pk?: Maybe<Follows>;
  /** update multiples rows of table: "follows" */
  update_follows_many?: Maybe<Array<Maybe<FollowsMutationResponse>>>;
  /** update data of the table: "metric_definitions" */
  update_metric_definitions?: Maybe<MetricDefinitionsMutationResponse>;
  /** update single row of the table: "metric_definitions" */
  update_metric_definitions_by_pk?: Maybe<MetricDefinitions>;
  /** update multiples rows of table: "metric_definitions" */
  update_metric_definitions_many?: Maybe<
    Array<Maybe<MetricDefinitionsMutationResponse>>
  >;
  /** update data of the table: "news" */
  update_news?: Maybe<NewsMutationResponse>;
  /** update single row of the table: "news" */
  update_news_by_pk?: Maybe<News>;
  /** update multiples rows of table: "news" */
  update_news_many?: Maybe<Array<Maybe<NewsMutationResponse>>>;
  /** update data of the table: "news_summaries" */
  update_news_summaries?: Maybe<NewsSummariesMutationResponse>;
  /** update single row of the table: "news_summaries" */
  update_news_summaries_by_pk?: Maybe<NewsSummaries>;
  /** update multiples rows of table: "news_summaries" */
  update_news_summaries_many?: Maybe<
    Array<Maybe<NewsSummariesMutationResponse>>
  >;
  /** update data of the table: "news_tags" */
  update_news_tags?: Maybe<NewsTagsMutationResponse>;
  /** update single row of the table: "news_tags" */
  update_news_tags_by_pk?: Maybe<NewsTags>;
  /** update multiples rows of table: "news_tags" */
  update_news_tags_many?: Maybe<Array<Maybe<NewsTagsMutationResponse>>>;
  /** update data of the table: "newsletters" */
  update_newsletters?: Maybe<NewslettersMutationResponse>;
  /** update single row of the table: "newsletters" */
  update_newsletters_by_pk?: Maybe<Newsletters>;
  /** update multiples rows of table: "newsletters" */
  update_newsletters_many?: Maybe<Array<Maybe<NewslettersMutationResponse>>>;
  /** update data of the table: "payment_providers" */
  update_payment_providers?: Maybe<PaymentProvidersMutationResponse>;
  /** update single row of the table: "payment_providers" */
  update_payment_providers_by_pk?: Maybe<PaymentProviders>;
  /** update multiples rows of table: "payment_providers" */
  update_payment_providers_many?: Maybe<
    Array<Maybe<PaymentProvidersMutationResponse>>
  >;
  /** update data of the table: "plan_permissions" */
  update_plan_permissions?: Maybe<PlanPermissionsMutationResponse>;
  /** update single row of the table: "plan_permissions" */
  update_plan_permissions_by_pk?: Maybe<PlanPermissions>;
  /** update multiples rows of table: "plan_permissions" */
  update_plan_permissions_many?: Maybe<
    Array<Maybe<PlanPermissionsMutationResponse>>
  >;
  /** update data of the table: "recent_errors" */
  update_recent_errors?: Maybe<RecentErrorsMutationResponse>;
  /** update multiples rows of table: "recent_errors" */
  update_recent_errors_many?: Maybe<Array<Maybe<RecentErrorsMutationResponse>>>;
  /** update data of the table: "referrals" */
  update_referrals?: Maybe<ReferralsMutationResponse>;
  /** update single row of the table: "referrals" */
  update_referrals_by_pk?: Maybe<Referrals>;
  /** update multiples rows of table: "referrals" */
  update_referrals_many?: Maybe<Array<Maybe<ReferralsMutationResponse>>>;
  /** update data of the table: "referrer_blocks" */
  update_referrer_blocks?: Maybe<ReferrerBlocksMutationResponse>;
  /** update single row of the table: "referrer_blocks" */
  update_referrer_blocks_by_pk?: Maybe<ReferrerBlocks>;
  /** update multiples rows of table: "referrer_blocks" */
  update_referrer_blocks_many?: Maybe<
    Array<Maybe<ReferrerBlocksMutationResponse>>
  >;
  /** update data of the table: "research" */
  update_research?: Maybe<ResearchMutationResponse>;
  /** update single row of the table: "research" */
  update_research_by_pk?: Maybe<Research>;
  /** update data of the table: "research_embeddings" */
  update_research_embeddings?: Maybe<ResearchEmbeddingsMutationResponse>;
  /** update single row of the table: "research_embeddings" */
  update_research_embeddings_by_pk?: Maybe<ResearchEmbeddings>;
  /** update multiples rows of table: "research_embeddings" */
  update_research_embeddings_many?: Maybe<
    Array<Maybe<ResearchEmbeddingsMutationResponse>>
  >;
  /** update multiples rows of table: "research" */
  update_research_many?: Maybe<Array<Maybe<ResearchMutationResponse>>>;
  /** update data of the table: "responses" */
  update_responses?: Maybe<ResponsesMutationResponse>;
  /** update single row of the table: "responses" */
  update_responses_by_pk?: Maybe<Responses>;
  /** update multiples rows of table: "responses" */
  update_responses_many?: Maybe<Array<Maybe<ResponsesMutationResponse>>>;
  /** update data of the table: "role_hierarchy" */
  update_role_hierarchy?: Maybe<RoleHierarchyMutationResponse>;
  /** update single row of the table: "role_hierarchy" */
  update_role_hierarchy_by_pk?: Maybe<RoleHierarchy>;
  /** update multiples rows of table: "role_hierarchy" */
  update_role_hierarchy_many?: Maybe<
    Array<Maybe<RoleHierarchyMutationResponse>>
  >;
  /** update data of the table: "role_permissions" */
  update_role_permissions?: Maybe<RolePermissionsMutationResponse>;
  /** update single row of the table: "role_permissions" */
  update_role_permissions_by_pk?: Maybe<RolePermissions>;
  /** update multiples rows of table: "role_permissions" */
  update_role_permissions_many?: Maybe<
    Array<Maybe<RolePermissionsMutationResponse>>
  >;
  /** update data of the table: "role_permissions_materialized" */
  update_role_permissions_materialized?: Maybe<RolePermissionsMaterializedMutationResponse>;
  /** update single row of the table: "role_permissions_materialized" */
  update_role_permissions_materialized_by_pk?: Maybe<RolePermissionsMaterialized>;
  /** update multiples rows of table: "role_permissions_materialized" */
  update_role_permissions_materialized_many?: Maybe<
    Array<Maybe<RolePermissionsMaterializedMutationResponse>>
  >;
  /** update data of the table: "scoring_weights" */
  update_scoring_weights?: Maybe<ScoringWeightsMutationResponse>;
  /** update single row of the table: "scoring_weights" */
  update_scoring_weights_by_pk?: Maybe<ScoringWeights>;
  /** update multiples rows of table: "scoring_weights" */
  update_scoring_weights_many?: Maybe<
    Array<Maybe<ScoringWeightsMutationResponse>>
  >;
  /** update data of the table: "searches" */
  update_searches?: Maybe<SearchesMutationResponse>;
  /** update single row of the table: "searches" */
  update_searches_by_pk?: Maybe<Searches>;
  /** update multiples rows of table: "searches" */
  update_searches_many?: Maybe<Array<Maybe<SearchesMutationResponse>>>;
  /** update data of the table: "social_media" */
  update_social_media?: Maybe<SocialMediaMutationResponse>;
  /** update single row of the table: "social_media" */
  update_social_media_by_pk?: Maybe<SocialMedia>;
  /** update multiples rows of table: "social_media" */
  update_social_media_many?: Maybe<Array<Maybe<SocialMediaMutationResponse>>>;
  /** update data of the table: "spider_metrics" */
  update_spider_metrics?: Maybe<SpiderMetricsMutationResponse>;
  /** update single row of the table: "spider_metrics" */
  update_spider_metrics_by_pk?: Maybe<SpiderMetrics>;
  /** update multiples rows of table: "spider_metrics" */
  update_spider_metrics_many?: Maybe<
    Array<Maybe<SpiderMetricsMutationResponse>>
  >;
  /** update data of the table: "strapi_migrations" */
  update_strapi_migrations?: Maybe<StrapiMigrationsMutationResponse>;
  /** update single row of the table: "strapi_migrations" */
  update_strapi_migrations_by_pk?: Maybe<StrapiMigrations>;
  /** update data of the table: "strapi_migrations_internal" */
  update_strapi_migrations_internal?: Maybe<StrapiMigrationsInternalMutationResponse>;
  /** update single row of the table: "strapi_migrations_internal" */
  update_strapi_migrations_internal_by_pk?: Maybe<StrapiMigrationsInternal>;
  /** update multiples rows of table: "strapi_migrations_internal" */
  update_strapi_migrations_internal_many?: Maybe<
    Array<Maybe<StrapiMigrationsInternalMutationResponse>>
  >;
  /** update multiples rows of table: "strapi_migrations" */
  update_strapi_migrations_many?: Maybe<
    Array<Maybe<StrapiMigrationsMutationResponse>>
  >;
  /** update data of the table: "table_maintenance_log" */
  update_table_maintenance_log?: Maybe<TableMaintenanceLogMutationResponse>;
  /** update single row of the table: "table_maintenance_log" */
  update_table_maintenance_log_by_pk?: Maybe<TableMaintenanceLog>;
  /** update multiples rows of table: "table_maintenance_log" */
  update_table_maintenance_log_many?: Maybe<
    Array<Maybe<TableMaintenanceLogMutationResponse>>
  >;
  /** update data of the table: "table_query_performance" */
  update_table_query_performance?: Maybe<TableQueryPerformanceMutationResponse>;
  /** update multiples rows of table: "table_query_performance" */
  update_table_query_performance_many?: Maybe<
    Array<Maybe<TableQueryPerformanceMutationResponse>>
  >;
  /** update data of the table: "table_sequence_usage" */
  update_table_sequence_usage?: Maybe<TableSequenceUsageMutationResponse>;
  /** update multiples rows of table: "table_sequence_usage" */
  update_table_sequence_usage_many?: Maybe<
    Array<Maybe<TableSequenceUsageMutationResponse>>
  >;
  /** update data of the table: "table_statistics" */
  update_table_statistics?: Maybe<TableStatisticsMutationResponse>;
  /** update single row of the table: "table_statistics" */
  update_table_statistics_by_pk?: Maybe<TableStatistics>;
  /** update multiples rows of table: "table_statistics" */
  update_table_statistics_many?: Maybe<
    Array<Maybe<TableStatisticsMutationResponse>>
  >;
  /** update data of the table: "tags" */
  update_tags?: Maybe<TagsMutationResponse>;
  /** update single row of the table: "tags" */
  update_tags_by_pk?: Maybe<Tags>;
  /** update multiples rows of table: "tags" */
  update_tags_many?: Maybe<Array<Maybe<TagsMutationResponse>>>;
  /** update data of the table: "user_metrics" */
  update_user_metrics?: Maybe<UserMetricsMutationResponse>;
  /** update single row of the table: "user_metrics" */
  update_user_metrics_by_pk?: Maybe<UserMetrics>;
  /** update multiples rows of table: "user_metrics" */
  update_user_metrics_many?: Maybe<Array<Maybe<UserMetricsMutationResponse>>>;
  /** update data of the table: "user_profiles" */
  update_user_profiles?: Maybe<UserProfilesMutationResponse>;
  /** update single row of the table: "user_profiles" */
  update_user_profiles_by_pk?: Maybe<UserProfiles>;
  /** update multiples rows of table: "user_profiles" */
  update_user_profiles_many?: Maybe<Array<Maybe<UserProfilesMutationResponse>>>;
  /** update data of the table: "votes" */
  update_votes?: Maybe<VotesMutationResponse>;
  /** update single row of the table: "votes" */
  update_votes_by_pk?: Maybe<Votes>;
  /** update multiples rows of table: "votes" */
  update_votes_many?: Maybe<Array<Maybe<VotesMutationResponse>>>;
  /** update data of the table: "workflows" */
  update_workflows?: Maybe<WorkflowsMutationResponse>;
  /** update single row of the table: "workflows" */
  update_workflows_by_pk?: Maybe<Workflows>;
  /** update multiples rows of table: "workflows" */
  update_workflows_many?: Maybe<Array<Maybe<WorkflowsMutationResponse>>>;
};

/** mutation root */
export type MutationRootDeleteAdDailyMetricsArgs = {
  where: AdDailyMetricsBoolExp;
};

/** mutation root */
export type MutationRootDeleteAdDailyMetricsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteAdPackagesArgs = {
  where: AdPackagesBoolExp;
};

/** mutation root */
export type MutationRootDeleteAdPackagesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteAdVariantsArgs = {
  where: AdVariantsBoolExp;
};

/** mutation root */
export type MutationRootDeleteAdVariantsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteAddressesArgs = {
  where: AddressesBoolExp;
};

/** mutation root */
export type MutationRootDeleteAddressesByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteAdsArgs = {
  where: AdsBoolExp;
};

/** mutation root */
export type MutationRootDeleteAdsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteBlacklistedDomainsArgs = {
  where: BlacklistedDomainsBoolExp;
};

/** mutation root */
export type MutationRootDeleteBlacklistedDomainsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteBlacklistedUrlsArgs = {
  where: BlacklistedUrlsBoolExp;
};

/** mutation root */
export type MutationRootDeleteBlacklistedUrlsByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteBlockedIpsArgs = {
  where: BlockedIpsBoolExp;
};

/** mutation root */
export type MutationRootDeleteBlockedIpsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteBookmarkFoldersArgs = {
  where: BookmarkFoldersBoolExp;
};

/** mutation root */
export type MutationRootDeleteBookmarkFoldersByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteBookmarksArgs = {
  where: BookmarksBoolExp;
};

/** mutation root */
export type MutationRootDeleteBookmarksByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteBusinessDomainsArgs = {
  where: BusinessDomainsBoolExp;
};

/** mutation root */
export type MutationRootDeleteBusinessDomainsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteCategoriesArgs = {
  where: CategoriesBoolExp;
};

/** mutation root */
export type MutationRootDeleteCategoriesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

/** mutation root */
export type MutationRootDeleteCategorizedUrlsArgs = {
  where: CategorizedUrlsBoolExp;
};

/** mutation root */
export type MutationRootDeleteCategorizedUrlsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteCircuitBreakerStatesArgs = {
  where: CircuitBreakerStatesBoolExp;
};

/** mutation root */
export type MutationRootDeleteCircuitBreakerStatesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteCitiesArgs = {
  where: CitiesBoolExp;
};

/** mutation root */
export type MutationRootDeleteCitiesByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteCommentsArgs = {
  where: CommentsBoolExp;
};

/** mutation root */
export type MutationRootDeleteCommentsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteCompaniesArgs = {
  where: CompaniesBoolExp;
};

/** mutation root */
export type MutationRootDeleteCompaniesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteCompanyContactsArgs = {
  where: CompanyContactsBoolExp;
};

/** mutation root */
export type MutationRootDeleteCompanyContactsByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteCompanyEmployeesArgs = {
  where: CompanyEmployeesBoolExp;
};

/** mutation root */
export type MutationRootDeleteCompanyEmployeesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteCompanyExtrasArgs = {
  where: CompanyExtrasBoolExp;
};

/** mutation root */
export type MutationRootDeleteCompanyExtrasByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteCompanyMetricsArgs = {
  where: CompanyMetricsBoolExp;
};

/** mutation root */
export type MutationRootDeleteCompanyMetricsByPkArgs = {
  id: Scalars["bigint"]["input"];
};

/** mutation root */
export type MutationRootDeleteContactsArgs = {
  where: ContactsBoolExp;
};

/** mutation root */
export type MutationRootDeleteContactsByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteContentCategoriesArgs = {
  where: ContentCategoriesBoolExp;
};

/** mutation root */
export type MutationRootDeleteContentCategoriesByPkArgs = {
  category_id: Scalars["bigint"]["input"];
  content_id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteContentSourceVisitsArgs = {
  where: ContentSourceVisitsBoolExp;
};

/** mutation root */
export type MutationRootDeleteContentSourceVisitsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteContentSourcesArgs = {
  where: ContentSourcesBoolExp;
};

/** mutation root */
export type MutationRootDeleteContentSourcesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

/** mutation root */
export type MutationRootDeleteContentStatusesArgs = {
  where: ContentStatusesBoolExp;
};

/** mutation root */
export type MutationRootDeleteContentStatusesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteContentTagsArgs = {
  where: ContentTagsBoolExp;
};

/** mutation root */
export type MutationRootDeleteContentTagsByPkArgs = {
  content_id: Scalars["uuid"]["input"];
  tag_id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteContentsArgs = {
  where: ContentsBoolExp;
};

/** mutation root */
export type MutationRootDeleteContentsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteCountriesArgs = {
  where: CountriesBoolExp;
};

/** mutation root */
export type MutationRootDeleteCountriesByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteCustomerPaymentsArgs = {
  where: CustomerPaymentsBoolExp;
};

/** mutation root */
export type MutationRootDeleteCustomerPaymentsByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteCustomerProcessedWebhooksArgs = {
  where: CustomerProcessedWebhooksBoolExp;
};

/** mutation root */
export type MutationRootDeleteCustomerProcessedWebhooksByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteCustomerRefundsArgs = {
  where: CustomerRefundsBoolExp;
};

/** mutation root */
export type MutationRootDeleteCustomerRefundsByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteCustomerSubscriptionPlansArgs = {
  where: CustomerSubscriptionPlansBoolExp;
};

/** mutation root */
export type MutationRootDeleteCustomerSubscriptionPlansByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteCustomerSubscriptionsArgs = {
  where: CustomerSubscriptionsBoolExp;
};

/** mutation root */
export type MutationRootDeleteCustomerSubscriptionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteEmbeddingReviewsArgs = {
  where: EmbeddingReviewsBoolExp;
};

/** mutation root */
export type MutationRootDeleteEmbeddingReviewsByPkArgs = {
  id: Scalars["bigint"]["input"];
};

/** mutation root */
export type MutationRootDeleteErrorLogsArgs = {
  where: ErrorLogsBoolExp;
};

/** mutation root */
export type MutationRootDeleteErrorLogsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteFeatureRequestsArgs = {
  where: FeatureRequestsBoolExp;
};

/** mutation root */
export type MutationRootDeleteFeatureRequestsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteFeatureVotesArgs = {
  where: FeatureVotesBoolExp;
};

/** mutation root */
export type MutationRootDeleteFeatureVotesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteFeedCategoriesArgs = {
  where: FeedCategoriesBoolExp;
};

/** mutation root */
export type MutationRootDeleteFeedCategoriesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

/** mutation root */
export type MutationRootDeleteFeedSourcesArgs = {
  where: FeedSourcesBoolExp;
};

/** mutation root */
export type MutationRootDeleteFeedSourcesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

/** mutation root */
export type MutationRootDeleteFeedbacksArgs = {
  where: FeedbacksBoolExp;
};

/** mutation root */
export type MutationRootDeleteFeedbacksByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteFeedsArgs = {
  where: FeedsBoolExp;
};

/** mutation root */
export type MutationRootDeleteFeedsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteFollowsArgs = {
  where: FollowsBoolExp;
};

/** mutation root */
export type MutationRootDeleteFollowsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteMetricDefinitionsArgs = {
  where: MetricDefinitionsBoolExp;
};

/** mutation root */
export type MutationRootDeleteMetricDefinitionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteNewsArgs = {
  where: NewsBoolExp;
};

/** mutation root */
export type MutationRootDeleteNewsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteNewsSummariesArgs = {
  where: NewsSummariesBoolExp;
};

/** mutation root */
export type MutationRootDeleteNewsSummariesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteNewsTagsArgs = {
  where: NewsTagsBoolExp;
};

/** mutation root */
export type MutationRootDeleteNewsTagsByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteNewslettersArgs = {
  where: NewslettersBoolExp;
};

/** mutation root */
export type MutationRootDeleteNewslettersByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeletePaymentProvidersArgs = {
  where: PaymentProvidersBoolExp;
};

/** mutation root */
export type MutationRootDeletePaymentProvidersByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeletePlanPermissionsArgs = {
  where: PlanPermissionsBoolExp;
};

/** mutation root */
export type MutationRootDeletePlanPermissionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteRecentErrorsArgs = {
  where: RecentErrorsBoolExp;
};

/** mutation root */
export type MutationRootDeleteReferralsArgs = {
  where: ReferralsBoolExp;
};

/** mutation root */
export type MutationRootDeleteReferralsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteReferrerBlocksArgs = {
  where: ReferrerBlocksBoolExp;
};

/** mutation root */
export type MutationRootDeleteReferrerBlocksByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteResearchArgs = {
  where: ResearchBoolExp;
};

/** mutation root */
export type MutationRootDeleteResearchByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteResearchEmbeddingsArgs = {
  where: ResearchEmbeddingsBoolExp;
};

/** mutation root */
export type MutationRootDeleteResearchEmbeddingsByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteResponsesArgs = {
  where: ResponsesBoolExp;
};

/** mutation root */
export type MutationRootDeleteResponsesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

/** mutation root */
export type MutationRootDeleteRoleHierarchyArgs = {
  where: RoleHierarchyBoolExp;
};

/** mutation root */
export type MutationRootDeleteRoleHierarchyByPkArgs = {
  child_role: Scalars["app_role_enum"]["input"];
  parent_role: Scalars["app_role_enum"]["input"];
};

/** mutation root */
export type MutationRootDeleteRolePermissionsArgs = {
  where: RolePermissionsBoolExp;
};

/** mutation root */
export type MutationRootDeleteRolePermissionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteRolePermissionsMaterializedArgs = {
  where: RolePermissionsMaterializedBoolExp;
};

/** mutation root */
export type MutationRootDeleteRolePermissionsMaterializedByPkArgs = {
  role: Scalars["app_role_enum"]["input"];
};

/** mutation root */
export type MutationRootDeleteScoringWeightsArgs = {
  where: ScoringWeightsBoolExp;
};

/** mutation root */
export type MutationRootDeleteScoringWeightsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteSearchesArgs = {
  where: SearchesBoolExp;
};

/** mutation root */
export type MutationRootDeleteSearchesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

/** mutation root */
export type MutationRootDeleteSocialMediaArgs = {
  where: SocialMediaBoolExp;
};

/** mutation root */
export type MutationRootDeleteSocialMediaByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteSpiderMetricsArgs = {
  where: SpiderMetricsBoolExp;
};

/** mutation root */
export type MutationRootDeleteSpiderMetricsByPkArgs = {
  id: Scalars["bigint"]["input"];
};

/** mutation root */
export type MutationRootDeleteStrapiMigrationsArgs = {
  where: StrapiMigrationsBoolExp;
};

/** mutation root */
export type MutationRootDeleteStrapiMigrationsByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteStrapiMigrationsInternalArgs = {
  where: StrapiMigrationsInternalBoolExp;
};

/** mutation root */
export type MutationRootDeleteStrapiMigrationsInternalByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteTableMaintenanceLogArgs = {
  where: TableMaintenanceLogBoolExp;
};

/** mutation root */
export type MutationRootDeleteTableMaintenanceLogByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteTableQueryPerformanceArgs = {
  where: TableQueryPerformanceBoolExp;
};

/** mutation root */
export type MutationRootDeleteTableSequenceUsageArgs = {
  where: TableSequenceUsageBoolExp;
};

/** mutation root */
export type MutationRootDeleteTableStatisticsArgs = {
  where: TableStatisticsBoolExp;
};

/** mutation root */
export type MutationRootDeleteTableStatisticsByPkArgs = {
  capture_time: Scalars["timestamptz"]["input"];
  table_name: Scalars["String"]["input"];
};

/** mutation root */
export type MutationRootDeleteTagsArgs = {
  where: TagsBoolExp;
};

/** mutation root */
export type MutationRootDeleteTagsByPkArgs = {
  id: Scalars["Int"]["input"];
};

/** mutation root */
export type MutationRootDeleteUserMetricsArgs = {
  where: UserMetricsBoolExp;
};

/** mutation root */
export type MutationRootDeleteUserMetricsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteUserProfilesArgs = {
  where: UserProfilesBoolExp;
};

/** mutation root */
export type MutationRootDeleteUserProfilesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteVotesArgs = {
  where: VotesBoolExp;
};

/** mutation root */
export type MutationRootDeleteVotesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootDeleteWorkflowsArgs = {
  where: WorkflowsBoolExp;
};

/** mutation root */
export type MutationRootDeleteWorkflowsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** mutation root */
export type MutationRootInsertAdDailyMetricsArgs = {
  objects: Array<AdDailyMetricsInsertInput>;
  on_conflict?: InputMaybe<AdDailyMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertAdDailyMetricsOneArgs = {
  object: AdDailyMetricsInsertInput;
  on_conflict?: InputMaybe<AdDailyMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertAdPackagesArgs = {
  objects: Array<AdPackagesInsertInput>;
  on_conflict?: InputMaybe<AdPackagesOnConflict>;
};

/** mutation root */
export type MutationRootInsertAdPackagesOneArgs = {
  object: AdPackagesInsertInput;
  on_conflict?: InputMaybe<AdPackagesOnConflict>;
};

/** mutation root */
export type MutationRootInsertAdVariantsArgs = {
  objects: Array<AdVariantsInsertInput>;
  on_conflict?: InputMaybe<AdVariantsOnConflict>;
};

/** mutation root */
export type MutationRootInsertAdVariantsOneArgs = {
  object: AdVariantsInsertInput;
  on_conflict?: InputMaybe<AdVariantsOnConflict>;
};

/** mutation root */
export type MutationRootInsertAddressesArgs = {
  objects: Array<AddressesInsertInput>;
  on_conflict?: InputMaybe<AddressesOnConflict>;
};

/** mutation root */
export type MutationRootInsertAddressesOneArgs = {
  object: AddressesInsertInput;
  on_conflict?: InputMaybe<AddressesOnConflict>;
};

/** mutation root */
export type MutationRootInsertAdsArgs = {
  objects: Array<AdsInsertInput>;
  on_conflict?: InputMaybe<AdsOnConflict>;
};

/** mutation root */
export type MutationRootInsertAdsOneArgs = {
  object: AdsInsertInput;
  on_conflict?: InputMaybe<AdsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBlacklistedDomainsArgs = {
  objects: Array<BlacklistedDomainsInsertInput>;
  on_conflict?: InputMaybe<BlacklistedDomainsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBlacklistedDomainsOneArgs = {
  object: BlacklistedDomainsInsertInput;
  on_conflict?: InputMaybe<BlacklistedDomainsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBlacklistedUrlsArgs = {
  objects: Array<BlacklistedUrlsInsertInput>;
  on_conflict?: InputMaybe<BlacklistedUrlsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBlacklistedUrlsOneArgs = {
  object: BlacklistedUrlsInsertInput;
  on_conflict?: InputMaybe<BlacklistedUrlsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBlockedIpsArgs = {
  objects: Array<BlockedIpsInsertInput>;
  on_conflict?: InputMaybe<BlockedIpsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBlockedIpsOneArgs = {
  object: BlockedIpsInsertInput;
  on_conflict?: InputMaybe<BlockedIpsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBookmarkFoldersArgs = {
  objects: Array<BookmarkFoldersInsertInput>;
  on_conflict?: InputMaybe<BookmarkFoldersOnConflict>;
};

/** mutation root */
export type MutationRootInsertBookmarkFoldersOneArgs = {
  object: BookmarkFoldersInsertInput;
  on_conflict?: InputMaybe<BookmarkFoldersOnConflict>;
};

/** mutation root */
export type MutationRootInsertBookmarksArgs = {
  objects: Array<BookmarksInsertInput>;
  on_conflict?: InputMaybe<BookmarksOnConflict>;
};

/** mutation root */
export type MutationRootInsertBookmarksOneArgs = {
  object: BookmarksInsertInput;
  on_conflict?: InputMaybe<BookmarksOnConflict>;
};

/** mutation root */
export type MutationRootInsertBusinessDomainsArgs = {
  objects: Array<BusinessDomainsInsertInput>;
  on_conflict?: InputMaybe<BusinessDomainsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBusinessDomainsOneArgs = {
  object: BusinessDomainsInsertInput;
  on_conflict?: InputMaybe<BusinessDomainsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCategoriesArgs = {
  objects: Array<CategoriesInsertInput>;
  on_conflict?: InputMaybe<CategoriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCategoriesOneArgs = {
  object: CategoriesInsertInput;
  on_conflict?: InputMaybe<CategoriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCategorizedUrlsArgs = {
  objects: Array<CategorizedUrlsInsertInput>;
  on_conflict?: InputMaybe<CategorizedUrlsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCategorizedUrlsOneArgs = {
  object: CategorizedUrlsInsertInput;
  on_conflict?: InputMaybe<CategorizedUrlsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCircuitBreakerStatesArgs = {
  objects: Array<CircuitBreakerStatesInsertInput>;
  on_conflict?: InputMaybe<CircuitBreakerStatesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCircuitBreakerStatesOneArgs = {
  object: CircuitBreakerStatesInsertInput;
  on_conflict?: InputMaybe<CircuitBreakerStatesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCitiesArgs = {
  objects: Array<CitiesInsertInput>;
  on_conflict?: InputMaybe<CitiesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCitiesOneArgs = {
  object: CitiesInsertInput;
  on_conflict?: InputMaybe<CitiesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCommentsArgs = {
  objects: Array<CommentsInsertInput>;
  on_conflict?: InputMaybe<CommentsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCommentsOneArgs = {
  object: CommentsInsertInput;
  on_conflict?: InputMaybe<CommentsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompaniesArgs = {
  objects: Array<CompaniesInsertInput>;
  on_conflict?: InputMaybe<CompaniesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompaniesOneArgs = {
  object: CompaniesInsertInput;
  on_conflict?: InputMaybe<CompaniesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyContactsArgs = {
  objects: Array<CompanyContactsInsertInput>;
  on_conflict?: InputMaybe<CompanyContactsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyContactsOneArgs = {
  object: CompanyContactsInsertInput;
  on_conflict?: InputMaybe<CompanyContactsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyEmployeesArgs = {
  objects: Array<CompanyEmployeesInsertInput>;
  on_conflict?: InputMaybe<CompanyEmployeesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyEmployeesOneArgs = {
  object: CompanyEmployeesInsertInput;
  on_conflict?: InputMaybe<CompanyEmployeesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyExtrasArgs = {
  objects: Array<CompanyExtrasInsertInput>;
  on_conflict?: InputMaybe<CompanyExtrasOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyExtrasOneArgs = {
  object: CompanyExtrasInsertInput;
  on_conflict?: InputMaybe<CompanyExtrasOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyMetricsArgs = {
  objects: Array<CompanyMetricsInsertInput>;
  on_conflict?: InputMaybe<CompanyMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyMetricsOneArgs = {
  object: CompanyMetricsInsertInput;
  on_conflict?: InputMaybe<CompanyMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContactsArgs = {
  objects: Array<ContactsInsertInput>;
  on_conflict?: InputMaybe<ContactsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContactsOneArgs = {
  object: ContactsInsertInput;
  on_conflict?: InputMaybe<ContactsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentCategoriesArgs = {
  objects: Array<ContentCategoriesInsertInput>;
  on_conflict?: InputMaybe<ContentCategoriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentCategoriesOneArgs = {
  object: ContentCategoriesInsertInput;
  on_conflict?: InputMaybe<ContentCategoriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentSourceVisitsArgs = {
  objects: Array<ContentSourceVisitsInsertInput>;
  on_conflict?: InputMaybe<ContentSourceVisitsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentSourceVisitsOneArgs = {
  object: ContentSourceVisitsInsertInput;
  on_conflict?: InputMaybe<ContentSourceVisitsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentSourcesArgs = {
  objects: Array<ContentSourcesInsertInput>;
  on_conflict?: InputMaybe<ContentSourcesOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentSourcesOneArgs = {
  object: ContentSourcesInsertInput;
  on_conflict?: InputMaybe<ContentSourcesOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentStatusesArgs = {
  objects: Array<ContentStatusesInsertInput>;
  on_conflict?: InputMaybe<ContentStatusesOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentStatusesOneArgs = {
  object: ContentStatusesInsertInput;
  on_conflict?: InputMaybe<ContentStatusesOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentTagsArgs = {
  objects: Array<ContentTagsInsertInput>;
  on_conflict?: InputMaybe<ContentTagsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentTagsOneArgs = {
  object: ContentTagsInsertInput;
  on_conflict?: InputMaybe<ContentTagsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentsArgs = {
  objects: Array<ContentsInsertInput>;
  on_conflict?: InputMaybe<ContentsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentsOneArgs = {
  object: ContentsInsertInput;
  on_conflict?: InputMaybe<ContentsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCountriesArgs = {
  objects: Array<CountriesInsertInput>;
  on_conflict?: InputMaybe<CountriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCountriesOneArgs = {
  object: CountriesInsertInput;
  on_conflict?: InputMaybe<CountriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerPaymentsArgs = {
  objects: Array<CustomerPaymentsInsertInput>;
  on_conflict?: InputMaybe<CustomerPaymentsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerPaymentsOneArgs = {
  object: CustomerPaymentsInsertInput;
  on_conflict?: InputMaybe<CustomerPaymentsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerProcessedWebhooksArgs = {
  objects: Array<CustomerProcessedWebhooksInsertInput>;
  on_conflict?: InputMaybe<CustomerProcessedWebhooksOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerProcessedWebhooksOneArgs = {
  object: CustomerProcessedWebhooksInsertInput;
  on_conflict?: InputMaybe<CustomerProcessedWebhooksOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerRefundsArgs = {
  objects: Array<CustomerRefundsInsertInput>;
  on_conflict?: InputMaybe<CustomerRefundsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerRefundsOneArgs = {
  object: CustomerRefundsInsertInput;
  on_conflict?: InputMaybe<CustomerRefundsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerSubscriptionPlansArgs = {
  objects: Array<CustomerSubscriptionPlansInsertInput>;
  on_conflict?: InputMaybe<CustomerSubscriptionPlansOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerSubscriptionPlansOneArgs = {
  object: CustomerSubscriptionPlansInsertInput;
  on_conflict?: InputMaybe<CustomerSubscriptionPlansOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerSubscriptionsArgs = {
  objects: Array<CustomerSubscriptionsInsertInput>;
  on_conflict?: InputMaybe<CustomerSubscriptionsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerSubscriptionsOneArgs = {
  object: CustomerSubscriptionsInsertInput;
  on_conflict?: InputMaybe<CustomerSubscriptionsOnConflict>;
};

/** mutation root */
export type MutationRootInsertEmbeddingReviewsArgs = {
  objects: Array<EmbeddingReviewsInsertInput>;
  on_conflict?: InputMaybe<EmbeddingReviewsOnConflict>;
};

/** mutation root */
export type MutationRootInsertEmbeddingReviewsOneArgs = {
  object: EmbeddingReviewsInsertInput;
  on_conflict?: InputMaybe<EmbeddingReviewsOnConflict>;
};

/** mutation root */
export type MutationRootInsertErrorLogsArgs = {
  objects: Array<ErrorLogsInsertInput>;
  on_conflict?: InputMaybe<ErrorLogsOnConflict>;
};

/** mutation root */
export type MutationRootInsertErrorLogsOneArgs = {
  object: ErrorLogsInsertInput;
  on_conflict?: InputMaybe<ErrorLogsOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeatureRequestsArgs = {
  objects: Array<FeatureRequestsInsertInput>;
  on_conflict?: InputMaybe<FeatureRequestsOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeatureRequestsOneArgs = {
  object: FeatureRequestsInsertInput;
  on_conflict?: InputMaybe<FeatureRequestsOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeatureVotesArgs = {
  objects: Array<FeatureVotesInsertInput>;
  on_conflict?: InputMaybe<FeatureVotesOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeatureVotesOneArgs = {
  object: FeatureVotesInsertInput;
  on_conflict?: InputMaybe<FeatureVotesOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedCategoriesArgs = {
  objects: Array<FeedCategoriesInsertInput>;
  on_conflict?: InputMaybe<FeedCategoriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedCategoriesOneArgs = {
  object: FeedCategoriesInsertInput;
  on_conflict?: InputMaybe<FeedCategoriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedSourcesArgs = {
  objects: Array<FeedSourcesInsertInput>;
  on_conflict?: InputMaybe<FeedSourcesOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedSourcesOneArgs = {
  object: FeedSourcesInsertInput;
  on_conflict?: InputMaybe<FeedSourcesOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedbacksArgs = {
  objects: Array<FeedbacksInsertInput>;
  on_conflict?: InputMaybe<FeedbacksOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedbacksOneArgs = {
  object: FeedbacksInsertInput;
  on_conflict?: InputMaybe<FeedbacksOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedsArgs = {
  objects: Array<FeedsInsertInput>;
  on_conflict?: InputMaybe<FeedsOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedsOneArgs = {
  object: FeedsInsertInput;
  on_conflict?: InputMaybe<FeedsOnConflict>;
};

/** mutation root */
export type MutationRootInsertFollowsArgs = {
  objects: Array<FollowsInsertInput>;
  on_conflict?: InputMaybe<FollowsOnConflict>;
};

/** mutation root */
export type MutationRootInsertFollowsOneArgs = {
  object: FollowsInsertInput;
  on_conflict?: InputMaybe<FollowsOnConflict>;
};

/** mutation root */
export type MutationRootInsertMetricDefinitionsArgs = {
  objects: Array<MetricDefinitionsInsertInput>;
  on_conflict?: InputMaybe<MetricDefinitionsOnConflict>;
};

/** mutation root */
export type MutationRootInsertMetricDefinitionsOneArgs = {
  object: MetricDefinitionsInsertInput;
  on_conflict?: InputMaybe<MetricDefinitionsOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewsArgs = {
  objects: Array<NewsInsertInput>;
  on_conflict?: InputMaybe<NewsOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewsOneArgs = {
  object: NewsInsertInput;
  on_conflict?: InputMaybe<NewsOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewsSummariesArgs = {
  objects: Array<NewsSummariesInsertInput>;
  on_conflict?: InputMaybe<NewsSummariesOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewsSummariesOneArgs = {
  object: NewsSummariesInsertInput;
  on_conflict?: InputMaybe<NewsSummariesOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewsTagsArgs = {
  objects: Array<NewsTagsInsertInput>;
  on_conflict?: InputMaybe<NewsTagsOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewsTagsOneArgs = {
  object: NewsTagsInsertInput;
  on_conflict?: InputMaybe<NewsTagsOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewslettersArgs = {
  objects: Array<NewslettersInsertInput>;
  on_conflict?: InputMaybe<NewslettersOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewslettersOneArgs = {
  object: NewslettersInsertInput;
  on_conflict?: InputMaybe<NewslettersOnConflict>;
};

/** mutation root */
export type MutationRootInsertPaymentProvidersArgs = {
  objects: Array<PaymentProvidersInsertInput>;
  on_conflict?: InputMaybe<PaymentProvidersOnConflict>;
};

/** mutation root */
export type MutationRootInsertPaymentProvidersOneArgs = {
  object: PaymentProvidersInsertInput;
  on_conflict?: InputMaybe<PaymentProvidersOnConflict>;
};

/** mutation root */
export type MutationRootInsertPlanPermissionsArgs = {
  objects: Array<PlanPermissionsInsertInput>;
  on_conflict?: InputMaybe<PlanPermissionsOnConflict>;
};

/** mutation root */
export type MutationRootInsertPlanPermissionsOneArgs = {
  object: PlanPermissionsInsertInput;
  on_conflict?: InputMaybe<PlanPermissionsOnConflict>;
};

/** mutation root */
export type MutationRootInsertRecentErrorsArgs = {
  objects: Array<RecentErrorsInsertInput>;
};

/** mutation root */
export type MutationRootInsertRecentErrorsOneArgs = {
  object: RecentErrorsInsertInput;
};

/** mutation root */
export type MutationRootInsertReferralsArgs = {
  objects: Array<ReferralsInsertInput>;
  on_conflict?: InputMaybe<ReferralsOnConflict>;
};

/** mutation root */
export type MutationRootInsertReferralsOneArgs = {
  object: ReferralsInsertInput;
  on_conflict?: InputMaybe<ReferralsOnConflict>;
};

/** mutation root */
export type MutationRootInsertReferrerBlocksArgs = {
  objects: Array<ReferrerBlocksInsertInput>;
  on_conflict?: InputMaybe<ReferrerBlocksOnConflict>;
};

/** mutation root */
export type MutationRootInsertReferrerBlocksOneArgs = {
  object: ReferrerBlocksInsertInput;
  on_conflict?: InputMaybe<ReferrerBlocksOnConflict>;
};

/** mutation root */
export type MutationRootInsertResearchArgs = {
  objects: Array<ResearchInsertInput>;
  on_conflict?: InputMaybe<ResearchOnConflict>;
};

/** mutation root */
export type MutationRootInsertResearchEmbeddingsArgs = {
  objects: Array<ResearchEmbeddingsInsertInput>;
  on_conflict?: InputMaybe<ResearchEmbeddingsOnConflict>;
};

/** mutation root */
export type MutationRootInsertResearchEmbeddingsOneArgs = {
  object: ResearchEmbeddingsInsertInput;
  on_conflict?: InputMaybe<ResearchEmbeddingsOnConflict>;
};

/** mutation root */
export type MutationRootInsertResearchOneArgs = {
  object: ResearchInsertInput;
  on_conflict?: InputMaybe<ResearchOnConflict>;
};

/** mutation root */
export type MutationRootInsertResponsesArgs = {
  objects: Array<ResponsesInsertInput>;
  on_conflict?: InputMaybe<ResponsesOnConflict>;
};

/** mutation root */
export type MutationRootInsertResponsesOneArgs = {
  object: ResponsesInsertInput;
  on_conflict?: InputMaybe<ResponsesOnConflict>;
};

/** mutation root */
export type MutationRootInsertRoleHierarchyArgs = {
  objects: Array<RoleHierarchyInsertInput>;
  on_conflict?: InputMaybe<RoleHierarchyOnConflict>;
};

/** mutation root */
export type MutationRootInsertRoleHierarchyOneArgs = {
  object: RoleHierarchyInsertInput;
  on_conflict?: InputMaybe<RoleHierarchyOnConflict>;
};

/** mutation root */
export type MutationRootInsertRolePermissionsArgs = {
  objects: Array<RolePermissionsInsertInput>;
  on_conflict?: InputMaybe<RolePermissionsOnConflict>;
};

/** mutation root */
export type MutationRootInsertRolePermissionsMaterializedArgs = {
  objects: Array<RolePermissionsMaterializedInsertInput>;
  on_conflict?: InputMaybe<RolePermissionsMaterializedOnConflict>;
};

/** mutation root */
export type MutationRootInsertRolePermissionsMaterializedOneArgs = {
  object: RolePermissionsMaterializedInsertInput;
  on_conflict?: InputMaybe<RolePermissionsMaterializedOnConflict>;
};

/** mutation root */
export type MutationRootInsertRolePermissionsOneArgs = {
  object: RolePermissionsInsertInput;
  on_conflict?: InputMaybe<RolePermissionsOnConflict>;
};

/** mutation root */
export type MutationRootInsertScoringWeightsArgs = {
  objects: Array<ScoringWeightsInsertInput>;
  on_conflict?: InputMaybe<ScoringWeightsOnConflict>;
};

/** mutation root */
export type MutationRootInsertScoringWeightsOneArgs = {
  object: ScoringWeightsInsertInput;
  on_conflict?: InputMaybe<ScoringWeightsOnConflict>;
};

/** mutation root */
export type MutationRootInsertSearchesArgs = {
  objects: Array<SearchesInsertInput>;
  on_conflict?: InputMaybe<SearchesOnConflict>;
};

/** mutation root */
export type MutationRootInsertSearchesOneArgs = {
  object: SearchesInsertInput;
  on_conflict?: InputMaybe<SearchesOnConflict>;
};

/** mutation root */
export type MutationRootInsertSocialMediaArgs = {
  objects: Array<SocialMediaInsertInput>;
  on_conflict?: InputMaybe<SocialMediaOnConflict>;
};

/** mutation root */
export type MutationRootInsertSocialMediaOneArgs = {
  object: SocialMediaInsertInput;
  on_conflict?: InputMaybe<SocialMediaOnConflict>;
};

/** mutation root */
export type MutationRootInsertSpiderMetricsArgs = {
  objects: Array<SpiderMetricsInsertInput>;
  on_conflict?: InputMaybe<SpiderMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertSpiderMetricsOneArgs = {
  object: SpiderMetricsInsertInput;
  on_conflict?: InputMaybe<SpiderMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertStrapiMigrationsArgs = {
  objects: Array<StrapiMigrationsInsertInput>;
  on_conflict?: InputMaybe<StrapiMigrationsOnConflict>;
};

/** mutation root */
export type MutationRootInsertStrapiMigrationsInternalArgs = {
  objects: Array<StrapiMigrationsInternalInsertInput>;
  on_conflict?: InputMaybe<StrapiMigrationsInternalOnConflict>;
};

/** mutation root */
export type MutationRootInsertStrapiMigrationsInternalOneArgs = {
  object: StrapiMigrationsInternalInsertInput;
  on_conflict?: InputMaybe<StrapiMigrationsInternalOnConflict>;
};

/** mutation root */
export type MutationRootInsertStrapiMigrationsOneArgs = {
  object: StrapiMigrationsInsertInput;
  on_conflict?: InputMaybe<StrapiMigrationsOnConflict>;
};

/** mutation root */
export type MutationRootInsertTableMaintenanceLogArgs = {
  objects: Array<TableMaintenanceLogInsertInput>;
  on_conflict?: InputMaybe<TableMaintenanceLogOnConflict>;
};

/** mutation root */
export type MutationRootInsertTableMaintenanceLogOneArgs = {
  object: TableMaintenanceLogInsertInput;
  on_conflict?: InputMaybe<TableMaintenanceLogOnConflict>;
};

/** mutation root */
export type MutationRootInsertTableQueryPerformanceArgs = {
  objects: Array<TableQueryPerformanceInsertInput>;
  on_conflict?: InputMaybe<TableQueryPerformanceOnConflict>;
};

/** mutation root */
export type MutationRootInsertTableQueryPerformanceOneArgs = {
  object: TableQueryPerformanceInsertInput;
  on_conflict?: InputMaybe<TableQueryPerformanceOnConflict>;
};

/** mutation root */
export type MutationRootInsertTableSequenceUsageArgs = {
  objects: Array<TableSequenceUsageInsertInput>;
  on_conflict?: InputMaybe<TableSequenceUsageOnConflict>;
};

/** mutation root */
export type MutationRootInsertTableSequenceUsageOneArgs = {
  object: TableSequenceUsageInsertInput;
  on_conflict?: InputMaybe<TableSequenceUsageOnConflict>;
};

/** mutation root */
export type MutationRootInsertTableStatisticsArgs = {
  objects: Array<TableStatisticsInsertInput>;
  on_conflict?: InputMaybe<TableStatisticsOnConflict>;
};

/** mutation root */
export type MutationRootInsertTableStatisticsOneArgs = {
  object: TableStatisticsInsertInput;
  on_conflict?: InputMaybe<TableStatisticsOnConflict>;
};

/** mutation root */
export type MutationRootInsertTagsArgs = {
  objects: Array<TagsInsertInput>;
  on_conflict?: InputMaybe<TagsOnConflict>;
};

/** mutation root */
export type MutationRootInsertTagsOneArgs = {
  object: TagsInsertInput;
  on_conflict?: InputMaybe<TagsOnConflict>;
};

/** mutation root */
export type MutationRootInsertUserMetricsArgs = {
  objects: Array<UserMetricsInsertInput>;
  on_conflict?: InputMaybe<UserMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertUserMetricsOneArgs = {
  object: UserMetricsInsertInput;
  on_conflict?: InputMaybe<UserMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertUserProfilesArgs = {
  objects: Array<UserProfilesInsertInput>;
  on_conflict?: InputMaybe<UserProfilesOnConflict>;
};

/** mutation root */
export type MutationRootInsertUserProfilesOneArgs = {
  object: UserProfilesInsertInput;
  on_conflict?: InputMaybe<UserProfilesOnConflict>;
};

/** mutation root */
export type MutationRootInsertVotesArgs = {
  objects: Array<VotesInsertInput>;
  on_conflict?: InputMaybe<VotesOnConflict>;
};

/** mutation root */
export type MutationRootInsertVotesOneArgs = {
  object: VotesInsertInput;
  on_conflict?: InputMaybe<VotesOnConflict>;
};

/** mutation root */
export type MutationRootInsertWorkflowsArgs = {
  objects: Array<WorkflowsInsertInput>;
  on_conflict?: InputMaybe<WorkflowsOnConflict>;
};

/** mutation root */
export type MutationRootInsertWorkflowsOneArgs = {
  object: WorkflowsInsertInput;
  on_conflict?: InputMaybe<WorkflowsOnConflict>;
};

/** mutation root */
export type MutationRootMatchResearchArgs = {
  args: MatchResearchArgs;
  distinct_on?: InputMaybe<Array<ResearchEmbeddingsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResearchEmbeddingsOrderBy>>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

/** mutation root */
export type MutationRootUpdateAdDailyMetricsArgs = {
  _inc?: InputMaybe<AdDailyMetricsIncInput>;
  _set?: InputMaybe<AdDailyMetricsSetInput>;
  where: AdDailyMetricsBoolExp;
};

/** mutation root */
export type MutationRootUpdateAdDailyMetricsByPkArgs = {
  _inc?: InputMaybe<AdDailyMetricsIncInput>;
  _set?: InputMaybe<AdDailyMetricsSetInput>;
  pk_columns: AdDailyMetricsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateAdDailyMetricsManyArgs = {
  updates: Array<AdDailyMetricsUpdates>;
};

/** mutation root */
export type MutationRootUpdateAdPackagesArgs = {
  _inc?: InputMaybe<AdPackagesIncInput>;
  _set?: InputMaybe<AdPackagesSetInput>;
  where: AdPackagesBoolExp;
};

/** mutation root */
export type MutationRootUpdateAdPackagesByPkArgs = {
  _inc?: InputMaybe<AdPackagesIncInput>;
  _set?: InputMaybe<AdPackagesSetInput>;
  pk_columns: AdPackagesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateAdPackagesManyArgs = {
  updates: Array<AdPackagesUpdates>;
};

/** mutation root */
export type MutationRootUpdateAdVariantsArgs = {
  _append?: InputMaybe<AdVariantsAppendInput>;
  _delete_at_path?: InputMaybe<AdVariantsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<AdVariantsDeleteElemInput>;
  _delete_key?: InputMaybe<AdVariantsDeleteKeyInput>;
  _prepend?: InputMaybe<AdVariantsPrependInput>;
  _set?: InputMaybe<AdVariantsSetInput>;
  where: AdVariantsBoolExp;
};

/** mutation root */
export type MutationRootUpdateAdVariantsByPkArgs = {
  _append?: InputMaybe<AdVariantsAppendInput>;
  _delete_at_path?: InputMaybe<AdVariantsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<AdVariantsDeleteElemInput>;
  _delete_key?: InputMaybe<AdVariantsDeleteKeyInput>;
  _prepend?: InputMaybe<AdVariantsPrependInput>;
  _set?: InputMaybe<AdVariantsSetInput>;
  pk_columns: AdVariantsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateAdVariantsManyArgs = {
  updates: Array<AdVariantsUpdates>;
};

/** mutation root */
export type MutationRootUpdateAddressesArgs = {
  _inc?: InputMaybe<AddressesIncInput>;
  _set?: InputMaybe<AddressesSetInput>;
  where: AddressesBoolExp;
};

/** mutation root */
export type MutationRootUpdateAddressesByPkArgs = {
  _inc?: InputMaybe<AddressesIncInput>;
  _set?: InputMaybe<AddressesSetInput>;
  pk_columns: AddressesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateAddressesManyArgs = {
  updates: Array<AddressesUpdates>;
};

/** mutation root */
export type MutationRootUpdateAdsArgs = {
  _set?: InputMaybe<AdsSetInput>;
  where: AdsBoolExp;
};

/** mutation root */
export type MutationRootUpdateAdsByPkArgs = {
  _set?: InputMaybe<AdsSetInput>;
  pk_columns: AdsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateAdsManyArgs = {
  updates: Array<AdsUpdates>;
};

/** mutation root */
export type MutationRootUpdateBlacklistedDomainsArgs = {
  _set?: InputMaybe<BlacklistedDomainsSetInput>;
  where: BlacklistedDomainsBoolExp;
};

/** mutation root */
export type MutationRootUpdateBlacklistedDomainsByPkArgs = {
  _set?: InputMaybe<BlacklistedDomainsSetInput>;
  pk_columns: BlacklistedDomainsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateBlacklistedDomainsManyArgs = {
  updates: Array<BlacklistedDomainsUpdates>;
};

/** mutation root */
export type MutationRootUpdateBlacklistedUrlsArgs = {
  _inc?: InputMaybe<BlacklistedUrlsIncInput>;
  _set?: InputMaybe<BlacklistedUrlsSetInput>;
  where: BlacklistedUrlsBoolExp;
};

/** mutation root */
export type MutationRootUpdateBlacklistedUrlsByPkArgs = {
  _inc?: InputMaybe<BlacklistedUrlsIncInput>;
  _set?: InputMaybe<BlacklistedUrlsSetInput>;
  pk_columns: BlacklistedUrlsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateBlacklistedUrlsManyArgs = {
  updates: Array<BlacklistedUrlsUpdates>;
};

/** mutation root */
export type MutationRootUpdateBlockedIpsArgs = {
  _inc?: InputMaybe<BlockedIpsIncInput>;
  _set?: InputMaybe<BlockedIpsSetInput>;
  where: BlockedIpsBoolExp;
};

/** mutation root */
export type MutationRootUpdateBlockedIpsByPkArgs = {
  _inc?: InputMaybe<BlockedIpsIncInput>;
  _set?: InputMaybe<BlockedIpsSetInput>;
  pk_columns: BlockedIpsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateBlockedIpsManyArgs = {
  updates: Array<BlockedIpsUpdates>;
};

/** mutation root */
export type MutationRootUpdateBookmarkFoldersArgs = {
  _inc?: InputMaybe<BookmarkFoldersIncInput>;
  _set?: InputMaybe<BookmarkFoldersSetInput>;
  where: BookmarkFoldersBoolExp;
};

/** mutation root */
export type MutationRootUpdateBookmarkFoldersByPkArgs = {
  _inc?: InputMaybe<BookmarkFoldersIncInput>;
  _set?: InputMaybe<BookmarkFoldersSetInput>;
  pk_columns: BookmarkFoldersPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateBookmarkFoldersManyArgs = {
  updates: Array<BookmarkFoldersUpdates>;
};

/** mutation root */
export type MutationRootUpdateBookmarksArgs = {
  _append?: InputMaybe<BookmarksAppendInput>;
  _delete_at_path?: InputMaybe<BookmarksDeleteAtPathInput>;
  _delete_elem?: InputMaybe<BookmarksDeleteElemInput>;
  _delete_key?: InputMaybe<BookmarksDeleteKeyInput>;
  _prepend?: InputMaybe<BookmarksPrependInput>;
  _set?: InputMaybe<BookmarksSetInput>;
  where: BookmarksBoolExp;
};

/** mutation root */
export type MutationRootUpdateBookmarksByPkArgs = {
  _append?: InputMaybe<BookmarksAppendInput>;
  _delete_at_path?: InputMaybe<BookmarksDeleteAtPathInput>;
  _delete_elem?: InputMaybe<BookmarksDeleteElemInput>;
  _delete_key?: InputMaybe<BookmarksDeleteKeyInput>;
  _prepend?: InputMaybe<BookmarksPrependInput>;
  _set?: InputMaybe<BookmarksSetInput>;
  pk_columns: BookmarksPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateBookmarksManyArgs = {
  updates: Array<BookmarksUpdates>;
};

/** mutation root */
export type MutationRootUpdateBusinessDomainsArgs = {
  _set?: InputMaybe<BusinessDomainsSetInput>;
  where: BusinessDomainsBoolExp;
};

/** mutation root */
export type MutationRootUpdateBusinessDomainsByPkArgs = {
  _set?: InputMaybe<BusinessDomainsSetInput>;
  pk_columns: BusinessDomainsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateBusinessDomainsManyArgs = {
  updates: Array<BusinessDomainsUpdates>;
};

/** mutation root */
export type MutationRootUpdateCategoriesArgs = {
  _inc?: InputMaybe<CategoriesIncInput>;
  _set?: InputMaybe<CategoriesSetInput>;
  where: CategoriesBoolExp;
};

/** mutation root */
export type MutationRootUpdateCategoriesByPkArgs = {
  _inc?: InputMaybe<CategoriesIncInput>;
  _set?: InputMaybe<CategoriesSetInput>;
  pk_columns: CategoriesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCategoriesManyArgs = {
  updates: Array<CategoriesUpdates>;
};

/** mutation root */
export type MutationRootUpdateCategorizedUrlsArgs = {
  _inc?: InputMaybe<CategorizedUrlsIncInput>;
  _set?: InputMaybe<CategorizedUrlsSetInput>;
  where: CategorizedUrlsBoolExp;
};

/** mutation root */
export type MutationRootUpdateCategorizedUrlsByPkArgs = {
  _inc?: InputMaybe<CategorizedUrlsIncInput>;
  _set?: InputMaybe<CategorizedUrlsSetInput>;
  pk_columns: CategorizedUrlsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCategorizedUrlsManyArgs = {
  updates: Array<CategorizedUrlsUpdates>;
};

/** mutation root */
export type MutationRootUpdateCircuitBreakerStatesArgs = {
  _inc?: InputMaybe<CircuitBreakerStatesIncInput>;
  _set?: InputMaybe<CircuitBreakerStatesSetInput>;
  where: CircuitBreakerStatesBoolExp;
};

/** mutation root */
export type MutationRootUpdateCircuitBreakerStatesByPkArgs = {
  _inc?: InputMaybe<CircuitBreakerStatesIncInput>;
  _set?: InputMaybe<CircuitBreakerStatesSetInput>;
  pk_columns: CircuitBreakerStatesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCircuitBreakerStatesManyArgs = {
  updates: Array<CircuitBreakerStatesUpdates>;
};

/** mutation root */
export type MutationRootUpdateCitiesArgs = {
  _inc?: InputMaybe<CitiesIncInput>;
  _set?: InputMaybe<CitiesSetInput>;
  where: CitiesBoolExp;
};

/** mutation root */
export type MutationRootUpdateCitiesByPkArgs = {
  _inc?: InputMaybe<CitiesIncInput>;
  _set?: InputMaybe<CitiesSetInput>;
  pk_columns: CitiesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCitiesManyArgs = {
  updates: Array<CitiesUpdates>;
};

/** mutation root */
export type MutationRootUpdateCommentsArgs = {
  _set?: InputMaybe<CommentsSetInput>;
  where: CommentsBoolExp;
};

/** mutation root */
export type MutationRootUpdateCommentsByPkArgs = {
  _set?: InputMaybe<CommentsSetInput>;
  pk_columns: CommentsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCommentsManyArgs = {
  updates: Array<CommentsUpdates>;
};

/** mutation root */
export type MutationRootUpdateCompaniesArgs = {
  _append?: InputMaybe<CompaniesAppendInput>;
  _delete_at_path?: InputMaybe<CompaniesDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CompaniesDeleteElemInput>;
  _delete_key?: InputMaybe<CompaniesDeleteKeyInput>;
  _inc?: InputMaybe<CompaniesIncInput>;
  _prepend?: InputMaybe<CompaniesPrependInput>;
  _set?: InputMaybe<CompaniesSetInput>;
  where: CompaniesBoolExp;
};

/** mutation root */
export type MutationRootUpdateCompaniesByPkArgs = {
  _append?: InputMaybe<CompaniesAppendInput>;
  _delete_at_path?: InputMaybe<CompaniesDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CompaniesDeleteElemInput>;
  _delete_key?: InputMaybe<CompaniesDeleteKeyInput>;
  _inc?: InputMaybe<CompaniesIncInput>;
  _prepend?: InputMaybe<CompaniesPrependInput>;
  _set?: InputMaybe<CompaniesSetInput>;
  pk_columns: CompaniesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCompaniesManyArgs = {
  updates: Array<CompaniesUpdates>;
};

/** mutation root */
export type MutationRootUpdateCompanyContactsArgs = {
  _inc?: InputMaybe<CompanyContactsIncInput>;
  _set?: InputMaybe<CompanyContactsSetInput>;
  where: CompanyContactsBoolExp;
};

/** mutation root */
export type MutationRootUpdateCompanyContactsByPkArgs = {
  _inc?: InputMaybe<CompanyContactsIncInput>;
  _set?: InputMaybe<CompanyContactsSetInput>;
  pk_columns: CompanyContactsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCompanyContactsManyArgs = {
  updates: Array<CompanyContactsUpdates>;
};

/** mutation root */
export type MutationRootUpdateCompanyEmployeesArgs = {
  _set?: InputMaybe<CompanyEmployeesSetInput>;
  where: CompanyEmployeesBoolExp;
};

/** mutation root */
export type MutationRootUpdateCompanyEmployeesByPkArgs = {
  _set?: InputMaybe<CompanyEmployeesSetInput>;
  pk_columns: CompanyEmployeesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCompanyEmployeesManyArgs = {
  updates: Array<CompanyEmployeesUpdates>;
};

/** mutation root */
export type MutationRootUpdateCompanyExtrasArgs = {
  _append?: InputMaybe<CompanyExtrasAppendInput>;
  _delete_at_path?: InputMaybe<CompanyExtrasDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CompanyExtrasDeleteElemInput>;
  _delete_key?: InputMaybe<CompanyExtrasDeleteKeyInput>;
  _inc?: InputMaybe<CompanyExtrasIncInput>;
  _prepend?: InputMaybe<CompanyExtrasPrependInput>;
  _set?: InputMaybe<CompanyExtrasSetInput>;
  where: CompanyExtrasBoolExp;
};

/** mutation root */
export type MutationRootUpdateCompanyExtrasByPkArgs = {
  _append?: InputMaybe<CompanyExtrasAppendInput>;
  _delete_at_path?: InputMaybe<CompanyExtrasDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CompanyExtrasDeleteElemInput>;
  _delete_key?: InputMaybe<CompanyExtrasDeleteKeyInput>;
  _inc?: InputMaybe<CompanyExtrasIncInput>;
  _prepend?: InputMaybe<CompanyExtrasPrependInput>;
  _set?: InputMaybe<CompanyExtrasSetInput>;
  pk_columns: CompanyExtrasPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCompanyExtrasManyArgs = {
  updates: Array<CompanyExtrasUpdates>;
};

/** mutation root */
export type MutationRootUpdateCompanyMetricsArgs = {
  _append?: InputMaybe<CompanyMetricsAppendInput>;
  _delete_at_path?: InputMaybe<CompanyMetricsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CompanyMetricsDeleteElemInput>;
  _delete_key?: InputMaybe<CompanyMetricsDeleteKeyInput>;
  _inc?: InputMaybe<CompanyMetricsIncInput>;
  _prepend?: InputMaybe<CompanyMetricsPrependInput>;
  _set?: InputMaybe<CompanyMetricsSetInput>;
  where: CompanyMetricsBoolExp;
};

/** mutation root */
export type MutationRootUpdateCompanyMetricsByPkArgs = {
  _append?: InputMaybe<CompanyMetricsAppendInput>;
  _delete_at_path?: InputMaybe<CompanyMetricsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CompanyMetricsDeleteElemInput>;
  _delete_key?: InputMaybe<CompanyMetricsDeleteKeyInput>;
  _inc?: InputMaybe<CompanyMetricsIncInput>;
  _prepend?: InputMaybe<CompanyMetricsPrependInput>;
  _set?: InputMaybe<CompanyMetricsSetInput>;
  pk_columns: CompanyMetricsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCompanyMetricsManyArgs = {
  updates: Array<CompanyMetricsUpdates>;
};

/** mutation root */
export type MutationRootUpdateContactsArgs = {
  _inc?: InputMaybe<ContactsIncInput>;
  _set?: InputMaybe<ContactsSetInput>;
  where: ContactsBoolExp;
};

/** mutation root */
export type MutationRootUpdateContactsByPkArgs = {
  _inc?: InputMaybe<ContactsIncInput>;
  _set?: InputMaybe<ContactsSetInput>;
  pk_columns: ContactsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateContactsManyArgs = {
  updates: Array<ContactsUpdates>;
};

/** mutation root */
export type MutationRootUpdateContentCategoriesArgs = {
  _inc?: InputMaybe<ContentCategoriesIncInput>;
  _set?: InputMaybe<ContentCategoriesSetInput>;
  where: ContentCategoriesBoolExp;
};

/** mutation root */
export type MutationRootUpdateContentCategoriesByPkArgs = {
  _inc?: InputMaybe<ContentCategoriesIncInput>;
  _set?: InputMaybe<ContentCategoriesSetInput>;
  pk_columns: ContentCategoriesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateContentCategoriesManyArgs = {
  updates: Array<ContentCategoriesUpdates>;
};

/** mutation root */
export type MutationRootUpdateContentSourceVisitsArgs = {
  _set?: InputMaybe<ContentSourceVisitsSetInput>;
  where: ContentSourceVisitsBoolExp;
};

/** mutation root */
export type MutationRootUpdateContentSourceVisitsByPkArgs = {
  _set?: InputMaybe<ContentSourceVisitsSetInput>;
  pk_columns: ContentSourceVisitsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateContentSourceVisitsManyArgs = {
  updates: Array<ContentSourceVisitsUpdates>;
};

/** mutation root */
export type MutationRootUpdateContentSourcesArgs = {
  _inc?: InputMaybe<ContentSourcesIncInput>;
  _set?: InputMaybe<ContentSourcesSetInput>;
  where: ContentSourcesBoolExp;
};

/** mutation root */
export type MutationRootUpdateContentSourcesByPkArgs = {
  _inc?: InputMaybe<ContentSourcesIncInput>;
  _set?: InputMaybe<ContentSourcesSetInput>;
  pk_columns: ContentSourcesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateContentSourcesManyArgs = {
  updates: Array<ContentSourcesUpdates>;
};

/** mutation root */
export type MutationRootUpdateContentStatusesArgs = {
  _set?: InputMaybe<ContentStatusesSetInput>;
  where: ContentStatusesBoolExp;
};

/** mutation root */
export type MutationRootUpdateContentStatusesByPkArgs = {
  _set?: InputMaybe<ContentStatusesSetInput>;
  pk_columns: ContentStatusesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateContentStatusesManyArgs = {
  updates: Array<ContentStatusesUpdates>;
};

/** mutation root */
export type MutationRootUpdateContentTagsArgs = {
  _inc?: InputMaybe<ContentTagsIncInput>;
  _set?: InputMaybe<ContentTagsSetInput>;
  where: ContentTagsBoolExp;
};

/** mutation root */
export type MutationRootUpdateContentTagsByPkArgs = {
  _inc?: InputMaybe<ContentTagsIncInput>;
  _set?: InputMaybe<ContentTagsSetInput>;
  pk_columns: ContentTagsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateContentTagsManyArgs = {
  updates: Array<ContentTagsUpdates>;
};

/** mutation root */
export type MutationRootUpdateContentsArgs = {
  _inc?: InputMaybe<ContentsIncInput>;
  _set?: InputMaybe<ContentsSetInput>;
  where: ContentsBoolExp;
};

/** mutation root */
export type MutationRootUpdateContentsByPkArgs = {
  _inc?: InputMaybe<ContentsIncInput>;
  _set?: InputMaybe<ContentsSetInput>;
  pk_columns: ContentsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateContentsManyArgs = {
  updates: Array<ContentsUpdates>;
};

/** mutation root */
export type MutationRootUpdateCountriesArgs = {
  _inc?: InputMaybe<CountriesIncInput>;
  _set?: InputMaybe<CountriesSetInput>;
  where: CountriesBoolExp;
};

/** mutation root */
export type MutationRootUpdateCountriesByPkArgs = {
  _inc?: InputMaybe<CountriesIncInput>;
  _set?: InputMaybe<CountriesSetInput>;
  pk_columns: CountriesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCountriesManyArgs = {
  updates: Array<CountriesUpdates>;
};

/** mutation root */
export type MutationRootUpdateCustomerPaymentsArgs = {
  _append?: InputMaybe<CustomerPaymentsAppendInput>;
  _delete_at_path?: InputMaybe<CustomerPaymentsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerPaymentsDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerPaymentsDeleteKeyInput>;
  _inc?: InputMaybe<CustomerPaymentsIncInput>;
  _prepend?: InputMaybe<CustomerPaymentsPrependInput>;
  _set?: InputMaybe<CustomerPaymentsSetInput>;
  where: CustomerPaymentsBoolExp;
};

/** mutation root */
export type MutationRootUpdateCustomerPaymentsByPkArgs = {
  _append?: InputMaybe<CustomerPaymentsAppendInput>;
  _delete_at_path?: InputMaybe<CustomerPaymentsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerPaymentsDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerPaymentsDeleteKeyInput>;
  _inc?: InputMaybe<CustomerPaymentsIncInput>;
  _prepend?: InputMaybe<CustomerPaymentsPrependInput>;
  _set?: InputMaybe<CustomerPaymentsSetInput>;
  pk_columns: CustomerPaymentsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCustomerPaymentsManyArgs = {
  updates: Array<CustomerPaymentsUpdates>;
};

/** mutation root */
export type MutationRootUpdateCustomerProcessedWebhooksArgs = {
  _inc?: InputMaybe<CustomerProcessedWebhooksIncInput>;
  _set?: InputMaybe<CustomerProcessedWebhooksSetInput>;
  where: CustomerProcessedWebhooksBoolExp;
};

/** mutation root */
export type MutationRootUpdateCustomerProcessedWebhooksByPkArgs = {
  _inc?: InputMaybe<CustomerProcessedWebhooksIncInput>;
  _set?: InputMaybe<CustomerProcessedWebhooksSetInput>;
  pk_columns: CustomerProcessedWebhooksPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCustomerProcessedWebhooksManyArgs = {
  updates: Array<CustomerProcessedWebhooksUpdates>;
};

/** mutation root */
export type MutationRootUpdateCustomerRefundsArgs = {
  _append?: InputMaybe<CustomerRefundsAppendInput>;
  _delete_at_path?: InputMaybe<CustomerRefundsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerRefundsDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerRefundsDeleteKeyInput>;
  _inc?: InputMaybe<CustomerRefundsIncInput>;
  _prepend?: InputMaybe<CustomerRefundsPrependInput>;
  _set?: InputMaybe<CustomerRefundsSetInput>;
  where: CustomerRefundsBoolExp;
};

/** mutation root */
export type MutationRootUpdateCustomerRefundsByPkArgs = {
  _append?: InputMaybe<CustomerRefundsAppendInput>;
  _delete_at_path?: InputMaybe<CustomerRefundsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerRefundsDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerRefundsDeleteKeyInput>;
  _inc?: InputMaybe<CustomerRefundsIncInput>;
  _prepend?: InputMaybe<CustomerRefundsPrependInput>;
  _set?: InputMaybe<CustomerRefundsSetInput>;
  pk_columns: CustomerRefundsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCustomerRefundsManyArgs = {
  updates: Array<CustomerRefundsUpdates>;
};

/** mutation root */
export type MutationRootUpdateCustomerSubscriptionPlansArgs = {
  _append?: InputMaybe<CustomerSubscriptionPlansAppendInput>;
  _delete_at_path?: InputMaybe<CustomerSubscriptionPlansDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerSubscriptionPlansDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerSubscriptionPlansDeleteKeyInput>;
  _inc?: InputMaybe<CustomerSubscriptionPlansIncInput>;
  _prepend?: InputMaybe<CustomerSubscriptionPlansPrependInput>;
  _set?: InputMaybe<CustomerSubscriptionPlansSetInput>;
  where: CustomerSubscriptionPlansBoolExp;
};

/** mutation root */
export type MutationRootUpdateCustomerSubscriptionPlansByPkArgs = {
  _append?: InputMaybe<CustomerSubscriptionPlansAppendInput>;
  _delete_at_path?: InputMaybe<CustomerSubscriptionPlansDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerSubscriptionPlansDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerSubscriptionPlansDeleteKeyInput>;
  _inc?: InputMaybe<CustomerSubscriptionPlansIncInput>;
  _prepend?: InputMaybe<CustomerSubscriptionPlansPrependInput>;
  _set?: InputMaybe<CustomerSubscriptionPlansSetInput>;
  pk_columns: CustomerSubscriptionPlansPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCustomerSubscriptionPlansManyArgs = {
  updates: Array<CustomerSubscriptionPlansUpdates>;
};

/** mutation root */
export type MutationRootUpdateCustomerSubscriptionsArgs = {
  _append?: InputMaybe<CustomerSubscriptionsAppendInput>;
  _delete_at_path?: InputMaybe<CustomerSubscriptionsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerSubscriptionsDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerSubscriptionsDeleteKeyInput>;
  _inc?: InputMaybe<CustomerSubscriptionsIncInput>;
  _prepend?: InputMaybe<CustomerSubscriptionsPrependInput>;
  _set?: InputMaybe<CustomerSubscriptionsSetInput>;
  where: CustomerSubscriptionsBoolExp;
};

/** mutation root */
export type MutationRootUpdateCustomerSubscriptionsByPkArgs = {
  _append?: InputMaybe<CustomerSubscriptionsAppendInput>;
  _delete_at_path?: InputMaybe<CustomerSubscriptionsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerSubscriptionsDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerSubscriptionsDeleteKeyInput>;
  _inc?: InputMaybe<CustomerSubscriptionsIncInput>;
  _prepend?: InputMaybe<CustomerSubscriptionsPrependInput>;
  _set?: InputMaybe<CustomerSubscriptionsSetInput>;
  pk_columns: CustomerSubscriptionsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateCustomerSubscriptionsManyArgs = {
  updates: Array<CustomerSubscriptionsUpdates>;
};

/** mutation root */
export type MutationRootUpdateEmbeddingReviewsArgs = {
  _inc?: InputMaybe<EmbeddingReviewsIncInput>;
  _set?: InputMaybe<EmbeddingReviewsSetInput>;
  where: EmbeddingReviewsBoolExp;
};

/** mutation root */
export type MutationRootUpdateEmbeddingReviewsByPkArgs = {
  _inc?: InputMaybe<EmbeddingReviewsIncInput>;
  _set?: InputMaybe<EmbeddingReviewsSetInput>;
  pk_columns: EmbeddingReviewsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateEmbeddingReviewsManyArgs = {
  updates: Array<EmbeddingReviewsUpdates>;
};

/** mutation root */
export type MutationRootUpdateErrorLogsArgs = {
  _append?: InputMaybe<ErrorLogsAppendInput>;
  _delete_at_path?: InputMaybe<ErrorLogsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<ErrorLogsDeleteElemInput>;
  _delete_key?: InputMaybe<ErrorLogsDeleteKeyInput>;
  _prepend?: InputMaybe<ErrorLogsPrependInput>;
  _set?: InputMaybe<ErrorLogsSetInput>;
  where: ErrorLogsBoolExp;
};

/** mutation root */
export type MutationRootUpdateErrorLogsByPkArgs = {
  _append?: InputMaybe<ErrorLogsAppendInput>;
  _delete_at_path?: InputMaybe<ErrorLogsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<ErrorLogsDeleteElemInput>;
  _delete_key?: InputMaybe<ErrorLogsDeleteKeyInput>;
  _prepend?: InputMaybe<ErrorLogsPrependInput>;
  _set?: InputMaybe<ErrorLogsSetInput>;
  pk_columns: ErrorLogsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateErrorLogsManyArgs = {
  updates: Array<ErrorLogsUpdates>;
};

/** mutation root */
export type MutationRootUpdateFeatureRequestsArgs = {
  _inc?: InputMaybe<FeatureRequestsIncInput>;
  _set?: InputMaybe<FeatureRequestsSetInput>;
  where: FeatureRequestsBoolExp;
};

/** mutation root */
export type MutationRootUpdateFeatureRequestsByPkArgs = {
  _inc?: InputMaybe<FeatureRequestsIncInput>;
  _set?: InputMaybe<FeatureRequestsSetInput>;
  pk_columns: FeatureRequestsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateFeatureRequestsManyArgs = {
  updates: Array<FeatureRequestsUpdates>;
};

/** mutation root */
export type MutationRootUpdateFeatureVotesArgs = {
  _inc?: InputMaybe<FeatureVotesIncInput>;
  _set?: InputMaybe<FeatureVotesSetInput>;
  where: FeatureVotesBoolExp;
};

/** mutation root */
export type MutationRootUpdateFeatureVotesByPkArgs = {
  _inc?: InputMaybe<FeatureVotesIncInput>;
  _set?: InputMaybe<FeatureVotesSetInput>;
  pk_columns: FeatureVotesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateFeatureVotesManyArgs = {
  updates: Array<FeatureVotesUpdates>;
};

/** mutation root */
export type MutationRootUpdateFeedCategoriesArgs = {
  _inc?: InputMaybe<FeedCategoriesIncInput>;
  _set?: InputMaybe<FeedCategoriesSetInput>;
  where: FeedCategoriesBoolExp;
};

/** mutation root */
export type MutationRootUpdateFeedCategoriesByPkArgs = {
  _inc?: InputMaybe<FeedCategoriesIncInput>;
  _set?: InputMaybe<FeedCategoriesSetInput>;
  pk_columns: FeedCategoriesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateFeedCategoriesManyArgs = {
  updates: Array<FeedCategoriesUpdates>;
};

/** mutation root */
export type MutationRootUpdateFeedSourcesArgs = {
  _inc?: InputMaybe<FeedSourcesIncInput>;
  _set?: InputMaybe<FeedSourcesSetInput>;
  where: FeedSourcesBoolExp;
};

/** mutation root */
export type MutationRootUpdateFeedSourcesByPkArgs = {
  _inc?: InputMaybe<FeedSourcesIncInput>;
  _set?: InputMaybe<FeedSourcesSetInput>;
  pk_columns: FeedSourcesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateFeedSourcesManyArgs = {
  updates: Array<FeedSourcesUpdates>;
};

/** mutation root */
export type MutationRootUpdateFeedbacksArgs = {
  _inc?: InputMaybe<FeedbacksIncInput>;
  _set?: InputMaybe<FeedbacksSetInput>;
  where: FeedbacksBoolExp;
};

/** mutation root */
export type MutationRootUpdateFeedbacksByPkArgs = {
  _inc?: InputMaybe<FeedbacksIncInput>;
  _set?: InputMaybe<FeedbacksSetInput>;
  pk_columns: FeedbacksPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateFeedbacksManyArgs = {
  updates: Array<FeedbacksUpdates>;
};

/** mutation root */
export type MutationRootUpdateFeedsArgs = {
  _set?: InputMaybe<FeedsSetInput>;
  where: FeedsBoolExp;
};

/** mutation root */
export type MutationRootUpdateFeedsByPkArgs = {
  _set?: InputMaybe<FeedsSetInput>;
  pk_columns: FeedsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateFeedsManyArgs = {
  updates: Array<FeedsUpdates>;
};

/** mutation root */
export type MutationRootUpdateFollowsArgs = {
  _set?: InputMaybe<FollowsSetInput>;
  where: FollowsBoolExp;
};

/** mutation root */
export type MutationRootUpdateFollowsByPkArgs = {
  _set?: InputMaybe<FollowsSetInput>;
  pk_columns: FollowsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateFollowsManyArgs = {
  updates: Array<FollowsUpdates>;
};

/** mutation root */
export type MutationRootUpdateMetricDefinitionsArgs = {
  _inc?: InputMaybe<MetricDefinitionsIncInput>;
  _set?: InputMaybe<MetricDefinitionsSetInput>;
  where: MetricDefinitionsBoolExp;
};

/** mutation root */
export type MutationRootUpdateMetricDefinitionsByPkArgs = {
  _inc?: InputMaybe<MetricDefinitionsIncInput>;
  _set?: InputMaybe<MetricDefinitionsSetInput>;
  pk_columns: MetricDefinitionsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateMetricDefinitionsManyArgs = {
  updates: Array<MetricDefinitionsUpdates>;
};

/** mutation root */
export type MutationRootUpdateNewsArgs = {
  _append?: InputMaybe<NewsAppendInput>;
  _delete_at_path?: InputMaybe<NewsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<NewsDeleteElemInput>;
  _delete_key?: InputMaybe<NewsDeleteKeyInput>;
  _inc?: InputMaybe<NewsIncInput>;
  _prepend?: InputMaybe<NewsPrependInput>;
  _set?: InputMaybe<NewsSetInput>;
  where: NewsBoolExp;
};

/** mutation root */
export type MutationRootUpdateNewsByPkArgs = {
  _append?: InputMaybe<NewsAppendInput>;
  _delete_at_path?: InputMaybe<NewsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<NewsDeleteElemInput>;
  _delete_key?: InputMaybe<NewsDeleteKeyInput>;
  _inc?: InputMaybe<NewsIncInput>;
  _prepend?: InputMaybe<NewsPrependInput>;
  _set?: InputMaybe<NewsSetInput>;
  pk_columns: NewsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateNewsManyArgs = {
  updates: Array<NewsUpdates>;
};

/** mutation root */
export type MutationRootUpdateNewsSummariesArgs = {
  _inc?: InputMaybe<NewsSummariesIncInput>;
  _set?: InputMaybe<NewsSummariesSetInput>;
  where: NewsSummariesBoolExp;
};

/** mutation root */
export type MutationRootUpdateNewsSummariesByPkArgs = {
  _inc?: InputMaybe<NewsSummariesIncInput>;
  _set?: InputMaybe<NewsSummariesSetInput>;
  pk_columns: NewsSummariesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateNewsSummariesManyArgs = {
  updates: Array<NewsSummariesUpdates>;
};

/** mutation root */
export type MutationRootUpdateNewsTagsArgs = {
  _inc?: InputMaybe<NewsTagsIncInput>;
  _set?: InputMaybe<NewsTagsSetInput>;
  where: NewsTagsBoolExp;
};

/** mutation root */
export type MutationRootUpdateNewsTagsByPkArgs = {
  _inc?: InputMaybe<NewsTagsIncInput>;
  _set?: InputMaybe<NewsTagsSetInput>;
  pk_columns: NewsTagsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateNewsTagsManyArgs = {
  updates: Array<NewsTagsUpdates>;
};

/** mutation root */
export type MutationRootUpdateNewslettersArgs = {
  _set?: InputMaybe<NewslettersSetInput>;
  where: NewslettersBoolExp;
};

/** mutation root */
export type MutationRootUpdateNewslettersByPkArgs = {
  _set?: InputMaybe<NewslettersSetInput>;
  pk_columns: NewslettersPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateNewslettersManyArgs = {
  updates: Array<NewslettersUpdates>;
};

/** mutation root */
export type MutationRootUpdatePaymentProvidersArgs = {
  _inc?: InputMaybe<PaymentProvidersIncInput>;
  _set?: InputMaybe<PaymentProvidersSetInput>;
  where: PaymentProvidersBoolExp;
};

/** mutation root */
export type MutationRootUpdatePaymentProvidersByPkArgs = {
  _inc?: InputMaybe<PaymentProvidersIncInput>;
  _set?: InputMaybe<PaymentProvidersSetInput>;
  pk_columns: PaymentProvidersPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdatePaymentProvidersManyArgs = {
  updates: Array<PaymentProvidersUpdates>;
};

/** mutation root */
export type MutationRootUpdatePlanPermissionsArgs = {
  _inc?: InputMaybe<PlanPermissionsIncInput>;
  _set?: InputMaybe<PlanPermissionsSetInput>;
  where: PlanPermissionsBoolExp;
};

/** mutation root */
export type MutationRootUpdatePlanPermissionsByPkArgs = {
  _inc?: InputMaybe<PlanPermissionsIncInput>;
  _set?: InputMaybe<PlanPermissionsSetInput>;
  pk_columns: PlanPermissionsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdatePlanPermissionsManyArgs = {
  updates: Array<PlanPermissionsUpdates>;
};

/** mutation root */
export type MutationRootUpdateRecentErrorsArgs = {
  _append?: InputMaybe<RecentErrorsAppendInput>;
  _delete_at_path?: InputMaybe<RecentErrorsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<RecentErrorsDeleteElemInput>;
  _delete_key?: InputMaybe<RecentErrorsDeleteKeyInput>;
  _prepend?: InputMaybe<RecentErrorsPrependInput>;
  _set?: InputMaybe<RecentErrorsSetInput>;
  where: RecentErrorsBoolExp;
};

/** mutation root */
export type MutationRootUpdateRecentErrorsManyArgs = {
  updates: Array<RecentErrorsUpdates>;
};

/** mutation root */
export type MutationRootUpdateReferralsArgs = {
  _append?: InputMaybe<ReferralsAppendInput>;
  _delete_at_path?: InputMaybe<ReferralsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<ReferralsDeleteElemInput>;
  _delete_key?: InputMaybe<ReferralsDeleteKeyInput>;
  _inc?: InputMaybe<ReferralsIncInput>;
  _prepend?: InputMaybe<ReferralsPrependInput>;
  _set?: InputMaybe<ReferralsSetInput>;
  where: ReferralsBoolExp;
};

/** mutation root */
export type MutationRootUpdateReferralsByPkArgs = {
  _append?: InputMaybe<ReferralsAppendInput>;
  _delete_at_path?: InputMaybe<ReferralsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<ReferralsDeleteElemInput>;
  _delete_key?: InputMaybe<ReferralsDeleteKeyInput>;
  _inc?: InputMaybe<ReferralsIncInput>;
  _prepend?: InputMaybe<ReferralsPrependInput>;
  _set?: InputMaybe<ReferralsSetInput>;
  pk_columns: ReferralsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateReferralsManyArgs = {
  updates: Array<ReferralsUpdates>;
};

/** mutation root */
export type MutationRootUpdateReferrerBlocksArgs = {
  _set?: InputMaybe<ReferrerBlocksSetInput>;
  where: ReferrerBlocksBoolExp;
};

/** mutation root */
export type MutationRootUpdateReferrerBlocksByPkArgs = {
  _set?: InputMaybe<ReferrerBlocksSetInput>;
  pk_columns: ReferrerBlocksPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateReferrerBlocksManyArgs = {
  updates: Array<ReferrerBlocksUpdates>;
};

/** mutation root */
export type MutationRootUpdateResearchArgs = {
  _append?: InputMaybe<ResearchAppendInput>;
  _delete_at_path?: InputMaybe<ResearchDeleteAtPathInput>;
  _delete_elem?: InputMaybe<ResearchDeleteElemInput>;
  _delete_key?: InputMaybe<ResearchDeleteKeyInput>;
  _inc?: InputMaybe<ResearchIncInput>;
  _prepend?: InputMaybe<ResearchPrependInput>;
  _set?: InputMaybe<ResearchSetInput>;
  where: ResearchBoolExp;
};

/** mutation root */
export type MutationRootUpdateResearchByPkArgs = {
  _append?: InputMaybe<ResearchAppendInput>;
  _delete_at_path?: InputMaybe<ResearchDeleteAtPathInput>;
  _delete_elem?: InputMaybe<ResearchDeleteElemInput>;
  _delete_key?: InputMaybe<ResearchDeleteKeyInput>;
  _inc?: InputMaybe<ResearchIncInput>;
  _prepend?: InputMaybe<ResearchPrependInput>;
  _set?: InputMaybe<ResearchSetInput>;
  pk_columns: ResearchPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateResearchEmbeddingsArgs = {
  _inc?: InputMaybe<ResearchEmbeddingsIncInput>;
  _set?: InputMaybe<ResearchEmbeddingsSetInput>;
  where: ResearchEmbeddingsBoolExp;
};

/** mutation root */
export type MutationRootUpdateResearchEmbeddingsByPkArgs = {
  _inc?: InputMaybe<ResearchEmbeddingsIncInput>;
  _set?: InputMaybe<ResearchEmbeddingsSetInput>;
  pk_columns: ResearchEmbeddingsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateResearchEmbeddingsManyArgs = {
  updates: Array<ResearchEmbeddingsUpdates>;
};

/** mutation root */
export type MutationRootUpdateResearchManyArgs = {
  updates: Array<ResearchUpdates>;
};

/** mutation root */
export type MutationRootUpdateResponsesArgs = {
  _inc?: InputMaybe<ResponsesIncInput>;
  _set?: InputMaybe<ResponsesSetInput>;
  where: ResponsesBoolExp;
};

/** mutation root */
export type MutationRootUpdateResponsesByPkArgs = {
  _inc?: InputMaybe<ResponsesIncInput>;
  _set?: InputMaybe<ResponsesSetInput>;
  pk_columns: ResponsesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateResponsesManyArgs = {
  updates: Array<ResponsesUpdates>;
};

/** mutation root */
export type MutationRootUpdateRoleHierarchyArgs = {
  _set?: InputMaybe<RoleHierarchySetInput>;
  where: RoleHierarchyBoolExp;
};

/** mutation root */
export type MutationRootUpdateRoleHierarchyByPkArgs = {
  _set?: InputMaybe<RoleHierarchySetInput>;
  pk_columns: RoleHierarchyPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateRoleHierarchyManyArgs = {
  updates: Array<RoleHierarchyUpdates>;
};

/** mutation root */
export type MutationRootUpdateRolePermissionsArgs = {
  _append?: InputMaybe<RolePermissionsAppendInput>;
  _delete_at_path?: InputMaybe<RolePermissionsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<RolePermissionsDeleteElemInput>;
  _delete_key?: InputMaybe<RolePermissionsDeleteKeyInput>;
  _inc?: InputMaybe<RolePermissionsIncInput>;
  _prepend?: InputMaybe<RolePermissionsPrependInput>;
  _set?: InputMaybe<RolePermissionsSetInput>;
  where: RolePermissionsBoolExp;
};

/** mutation root */
export type MutationRootUpdateRolePermissionsByPkArgs = {
  _append?: InputMaybe<RolePermissionsAppendInput>;
  _delete_at_path?: InputMaybe<RolePermissionsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<RolePermissionsDeleteElemInput>;
  _delete_key?: InputMaybe<RolePermissionsDeleteKeyInput>;
  _inc?: InputMaybe<RolePermissionsIncInput>;
  _prepend?: InputMaybe<RolePermissionsPrependInput>;
  _set?: InputMaybe<RolePermissionsSetInput>;
  pk_columns: RolePermissionsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateRolePermissionsManyArgs = {
  updates: Array<RolePermissionsUpdates>;
};

/** mutation root */
export type MutationRootUpdateRolePermissionsMaterializedArgs = {
  _append?: InputMaybe<RolePermissionsMaterializedAppendInput>;
  _delete_at_path?: InputMaybe<RolePermissionsMaterializedDeleteAtPathInput>;
  _delete_elem?: InputMaybe<RolePermissionsMaterializedDeleteElemInput>;
  _delete_key?: InputMaybe<RolePermissionsMaterializedDeleteKeyInput>;
  _prepend?: InputMaybe<RolePermissionsMaterializedPrependInput>;
  _set?: InputMaybe<RolePermissionsMaterializedSetInput>;
  where: RolePermissionsMaterializedBoolExp;
};

/** mutation root */
export type MutationRootUpdateRolePermissionsMaterializedByPkArgs = {
  _append?: InputMaybe<RolePermissionsMaterializedAppendInput>;
  _delete_at_path?: InputMaybe<RolePermissionsMaterializedDeleteAtPathInput>;
  _delete_elem?: InputMaybe<RolePermissionsMaterializedDeleteElemInput>;
  _delete_key?: InputMaybe<RolePermissionsMaterializedDeleteKeyInput>;
  _prepend?: InputMaybe<RolePermissionsMaterializedPrependInput>;
  _set?: InputMaybe<RolePermissionsMaterializedSetInput>;
  pk_columns: RolePermissionsMaterializedPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateRolePermissionsMaterializedManyArgs = {
  updates: Array<RolePermissionsMaterializedUpdates>;
};

/** mutation root */
export type MutationRootUpdateScoringWeightsArgs = {
  _inc?: InputMaybe<ScoringWeightsIncInput>;
  _set?: InputMaybe<ScoringWeightsSetInput>;
  where: ScoringWeightsBoolExp;
};

/** mutation root */
export type MutationRootUpdateScoringWeightsByPkArgs = {
  _inc?: InputMaybe<ScoringWeightsIncInput>;
  _set?: InputMaybe<ScoringWeightsSetInput>;
  pk_columns: ScoringWeightsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateScoringWeightsManyArgs = {
  updates: Array<ScoringWeightsUpdates>;
};

/** mutation root */
export type MutationRootUpdateSearchesArgs = {
  _inc?: InputMaybe<SearchesIncInput>;
  _set?: InputMaybe<SearchesSetInput>;
  where: SearchesBoolExp;
};

/** mutation root */
export type MutationRootUpdateSearchesByPkArgs = {
  _inc?: InputMaybe<SearchesIncInput>;
  _set?: InputMaybe<SearchesSetInput>;
  pk_columns: SearchesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateSearchesManyArgs = {
  updates: Array<SearchesUpdates>;
};

/** mutation root */
export type MutationRootUpdateSocialMediaArgs = {
  _inc?: InputMaybe<SocialMediaIncInput>;
  _set?: InputMaybe<SocialMediaSetInput>;
  where: SocialMediaBoolExp;
};

/** mutation root */
export type MutationRootUpdateSocialMediaByPkArgs = {
  _inc?: InputMaybe<SocialMediaIncInput>;
  _set?: InputMaybe<SocialMediaSetInput>;
  pk_columns: SocialMediaPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateSocialMediaManyArgs = {
  updates: Array<SocialMediaUpdates>;
};

/** mutation root */
export type MutationRootUpdateSpiderMetricsArgs = {
  _append?: InputMaybe<SpiderMetricsAppendInput>;
  _delete_at_path?: InputMaybe<SpiderMetricsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<SpiderMetricsDeleteElemInput>;
  _delete_key?: InputMaybe<SpiderMetricsDeleteKeyInput>;
  _inc?: InputMaybe<SpiderMetricsIncInput>;
  _prepend?: InputMaybe<SpiderMetricsPrependInput>;
  _set?: InputMaybe<SpiderMetricsSetInput>;
  where: SpiderMetricsBoolExp;
};

/** mutation root */
export type MutationRootUpdateSpiderMetricsByPkArgs = {
  _append?: InputMaybe<SpiderMetricsAppendInput>;
  _delete_at_path?: InputMaybe<SpiderMetricsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<SpiderMetricsDeleteElemInput>;
  _delete_key?: InputMaybe<SpiderMetricsDeleteKeyInput>;
  _inc?: InputMaybe<SpiderMetricsIncInput>;
  _prepend?: InputMaybe<SpiderMetricsPrependInput>;
  _set?: InputMaybe<SpiderMetricsSetInput>;
  pk_columns: SpiderMetricsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateSpiderMetricsManyArgs = {
  updates: Array<SpiderMetricsUpdates>;
};

/** mutation root */
export type MutationRootUpdateStrapiMigrationsArgs = {
  _inc?: InputMaybe<StrapiMigrationsIncInput>;
  _set?: InputMaybe<StrapiMigrationsSetInput>;
  where: StrapiMigrationsBoolExp;
};

/** mutation root */
export type MutationRootUpdateStrapiMigrationsByPkArgs = {
  _inc?: InputMaybe<StrapiMigrationsIncInput>;
  _set?: InputMaybe<StrapiMigrationsSetInput>;
  pk_columns: StrapiMigrationsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateStrapiMigrationsInternalArgs = {
  _inc?: InputMaybe<StrapiMigrationsInternalIncInput>;
  _set?: InputMaybe<StrapiMigrationsInternalSetInput>;
  where: StrapiMigrationsInternalBoolExp;
};

/** mutation root */
export type MutationRootUpdateStrapiMigrationsInternalByPkArgs = {
  _inc?: InputMaybe<StrapiMigrationsInternalIncInput>;
  _set?: InputMaybe<StrapiMigrationsInternalSetInput>;
  pk_columns: StrapiMigrationsInternalPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateStrapiMigrationsInternalManyArgs = {
  updates: Array<StrapiMigrationsInternalUpdates>;
};

/** mutation root */
export type MutationRootUpdateStrapiMigrationsManyArgs = {
  updates: Array<StrapiMigrationsUpdates>;
};

/** mutation root */
export type MutationRootUpdateTableMaintenanceLogArgs = {
  _inc?: InputMaybe<TableMaintenanceLogIncInput>;
  _set?: InputMaybe<TableMaintenanceLogSetInput>;
  where: TableMaintenanceLogBoolExp;
};

/** mutation root */
export type MutationRootUpdateTableMaintenanceLogByPkArgs = {
  _inc?: InputMaybe<TableMaintenanceLogIncInput>;
  _set?: InputMaybe<TableMaintenanceLogSetInput>;
  pk_columns: TableMaintenanceLogPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateTableMaintenanceLogManyArgs = {
  updates: Array<TableMaintenanceLogUpdates>;
};

/** mutation root */
export type MutationRootUpdateTableQueryPerformanceArgs = {
  _inc?: InputMaybe<TableQueryPerformanceIncInput>;
  _set?: InputMaybe<TableQueryPerformanceSetInput>;
  where: TableQueryPerformanceBoolExp;
};

/** mutation root */
export type MutationRootUpdateTableQueryPerformanceManyArgs = {
  updates: Array<TableQueryPerformanceUpdates>;
};

/** mutation root */
export type MutationRootUpdateTableSequenceUsageArgs = {
  _inc?: InputMaybe<TableSequenceUsageIncInput>;
  _set?: InputMaybe<TableSequenceUsageSetInput>;
  where: TableSequenceUsageBoolExp;
};

/** mutation root */
export type MutationRootUpdateTableSequenceUsageManyArgs = {
  updates: Array<TableSequenceUsageUpdates>;
};

/** mutation root */
export type MutationRootUpdateTableStatisticsArgs = {
  _append?: InputMaybe<TableStatisticsAppendInput>;
  _delete_at_path?: InputMaybe<TableStatisticsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<TableStatisticsDeleteElemInput>;
  _delete_key?: InputMaybe<TableStatisticsDeleteKeyInput>;
  _inc?: InputMaybe<TableStatisticsIncInput>;
  _prepend?: InputMaybe<TableStatisticsPrependInput>;
  _set?: InputMaybe<TableStatisticsSetInput>;
  where: TableStatisticsBoolExp;
};

/** mutation root */
export type MutationRootUpdateTableStatisticsByPkArgs = {
  _append?: InputMaybe<TableStatisticsAppendInput>;
  _delete_at_path?: InputMaybe<TableStatisticsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<TableStatisticsDeleteElemInput>;
  _delete_key?: InputMaybe<TableStatisticsDeleteKeyInput>;
  _inc?: InputMaybe<TableStatisticsIncInput>;
  _prepend?: InputMaybe<TableStatisticsPrependInput>;
  _set?: InputMaybe<TableStatisticsSetInput>;
  pk_columns: TableStatisticsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateTableStatisticsManyArgs = {
  updates: Array<TableStatisticsUpdates>;
};

/** mutation root */
export type MutationRootUpdateTagsArgs = {
  _inc?: InputMaybe<TagsIncInput>;
  _set?: InputMaybe<TagsSetInput>;
  where: TagsBoolExp;
};

/** mutation root */
export type MutationRootUpdateTagsByPkArgs = {
  _inc?: InputMaybe<TagsIncInput>;
  _set?: InputMaybe<TagsSetInput>;
  pk_columns: TagsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateTagsManyArgs = {
  updates: Array<TagsUpdates>;
};

/** mutation root */
export type MutationRootUpdateUserMetricsArgs = {
  _append?: InputMaybe<UserMetricsAppendInput>;
  _delete_at_path?: InputMaybe<UserMetricsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<UserMetricsDeleteElemInput>;
  _delete_key?: InputMaybe<UserMetricsDeleteKeyInput>;
  _inc?: InputMaybe<UserMetricsIncInput>;
  _prepend?: InputMaybe<UserMetricsPrependInput>;
  _set?: InputMaybe<UserMetricsSetInput>;
  where: UserMetricsBoolExp;
};

/** mutation root */
export type MutationRootUpdateUserMetricsByPkArgs = {
  _append?: InputMaybe<UserMetricsAppendInput>;
  _delete_at_path?: InputMaybe<UserMetricsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<UserMetricsDeleteElemInput>;
  _delete_key?: InputMaybe<UserMetricsDeleteKeyInput>;
  _inc?: InputMaybe<UserMetricsIncInput>;
  _prepend?: InputMaybe<UserMetricsPrependInput>;
  _set?: InputMaybe<UserMetricsSetInput>;
  pk_columns: UserMetricsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateUserMetricsManyArgs = {
  updates: Array<UserMetricsUpdates>;
};

/** mutation root */
export type MutationRootUpdateUserProfilesArgs = {
  _inc?: InputMaybe<UserProfilesIncInput>;
  _set?: InputMaybe<UserProfilesSetInput>;
  where: UserProfilesBoolExp;
};

/** mutation root */
export type MutationRootUpdateUserProfilesByPkArgs = {
  _inc?: InputMaybe<UserProfilesIncInput>;
  _set?: InputMaybe<UserProfilesSetInput>;
  pk_columns: UserProfilesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateUserProfilesManyArgs = {
  updates: Array<UserProfilesUpdates>;
};

/** mutation root */
export type MutationRootUpdateVotesArgs = {
  _inc?: InputMaybe<VotesIncInput>;
  _set?: InputMaybe<VotesSetInput>;
  where: VotesBoolExp;
};

/** mutation root */
export type MutationRootUpdateVotesByPkArgs = {
  _inc?: InputMaybe<VotesIncInput>;
  _set?: InputMaybe<VotesSetInput>;
  pk_columns: VotesPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateVotesManyArgs = {
  updates: Array<VotesUpdates>;
};

/** mutation root */
export type MutationRootUpdateWorkflowsArgs = {
  _append?: InputMaybe<WorkflowsAppendInput>;
  _delete_at_path?: InputMaybe<WorkflowsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<WorkflowsDeleteElemInput>;
  _delete_key?: InputMaybe<WorkflowsDeleteKeyInput>;
  _prepend?: InputMaybe<WorkflowsPrependInput>;
  _set?: InputMaybe<WorkflowsSetInput>;
  where: WorkflowsBoolExp;
};

/** mutation root */
export type MutationRootUpdateWorkflowsByPkArgs = {
  _append?: InputMaybe<WorkflowsAppendInput>;
  _delete_at_path?: InputMaybe<WorkflowsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<WorkflowsDeleteElemInput>;
  _delete_key?: InputMaybe<WorkflowsDeleteKeyInput>;
  _prepend?: InputMaybe<WorkflowsPrependInput>;
  _set?: InputMaybe<WorkflowsSetInput>;
  pk_columns: WorkflowsPkColumnsInput;
};

/** mutation root */
export type MutationRootUpdateWorkflowsManyArgs = {
  updates: Array<WorkflowsUpdates>;
};

/** columns and relationships of "news" */
export type News = {
  __typename?: "news";
  author?: Maybe<Scalars["String"]["output"]>;
  body?: Maybe<Scalars["String"]["output"]>;
  /** An object relationship */
  category?: Maybe<Categories>;
  category_id?: Maybe<Scalars["bigint"]["output"]>;
  /** An object relationship */
  company?: Maybe<Companies>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  /** An object relationship */
  content: Contents;
  /** An object relationship */
  content_source?: Maybe<ContentSources>;
  content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  content_status: Scalars["content_status"]["output"];
  created_at: Scalars["timestamptz"]["output"];
  description?: Maybe<Scalars["String"]["output"]>;
  failed_count?: Maybe<Scalars["smallint"]["output"]>;
  featured_image?: Maybe<Scalars["String"]["output"]>;
  has_summary: Scalars["Boolean"]["output"];
  hash?: Maybe<Scalars["bigint"]["output"]>;
  id: Scalars["uuid"]["output"];
  keywords?: Maybe<Scalars["jsonb"]["output"]>;
  /** An array relationship */
  news_summaries: Array<NewsSummaries>;
  /** An aggregate relationship */
  news_summaries_aggregate: NewsSummariesAggregate;
  published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  scrape_frequency: Scalars["scrape_frequency"]["output"];
  scraped_at?: Maybe<Scalars["timestamptz"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at: Scalars["timestamptz"]["output"];
  url: Scalars["String"]["output"];
};

/** columns and relationships of "news" */
export type NewsKeywordsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "news" */
export type NewsNewsSummariesArgs = {
  distinct_on?: InputMaybe<Array<NewsSummariesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsSummariesOrderBy>>;
  where?: InputMaybe<NewsSummariesBoolExp>;
};

/** columns and relationships of "news" */
export type NewsNewsSummariesAggregateArgs = {
  distinct_on?: InputMaybe<Array<NewsSummariesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsSummariesOrderBy>>;
  where?: InputMaybe<NewsSummariesBoolExp>;
};

/** aggregated selection of "news" */
export type NewsAggregate = {
  __typename?: "news_aggregate";
  aggregate?: Maybe<NewsAggregateFields>;
  nodes: Array<News>;
};

export type NewsAggregateBoolExp = {
  bool_and?: InputMaybe<NewsAggregateBoolExpBoolAnd>;
  bool_or?: InputMaybe<NewsAggregateBoolExpBoolOr>;
  count?: InputMaybe<NewsAggregateBoolExpCount>;
};

export type NewsAggregateBoolExpBoolAnd = {
  arguments: NewsSelectColumnNewsAggregateBoolExpBoolAndArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<NewsBoolExp>;
  predicate: BooleanComparisonExp;
};

export type NewsAggregateBoolExpBoolOr = {
  arguments: NewsSelectColumnNewsAggregateBoolExpBoolOrArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<NewsBoolExp>;
  predicate: BooleanComparisonExp;
};

export type NewsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<NewsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<NewsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "news" */
export type NewsAggregateFields = {
  __typename?: "news_aggregate_fields";
  avg?: Maybe<NewsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<NewsMaxFields>;
  min?: Maybe<NewsMinFields>;
  stddev?: Maybe<NewsStddevFields>;
  stddev_pop?: Maybe<NewsStddevPopFields>;
  stddev_samp?: Maybe<NewsStddevSampFields>;
  sum?: Maybe<NewsSumFields>;
  var_pop?: Maybe<NewsVarPopFields>;
  var_samp?: Maybe<NewsVarSampFields>;
  variance?: Maybe<NewsVarianceFields>;
};

/** aggregate fields of "news" */
export type NewsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<NewsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "news" */
export type NewsAggregateOrderBy = {
  avg?: InputMaybe<NewsAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<NewsMaxOrderBy>;
  min?: InputMaybe<NewsMinOrderBy>;
  stddev?: InputMaybe<NewsStddevOrderBy>;
  stddev_pop?: InputMaybe<NewsStddevPopOrderBy>;
  stddev_samp?: InputMaybe<NewsStddevSampOrderBy>;
  sum?: InputMaybe<NewsSumOrderBy>;
  var_pop?: InputMaybe<NewsVarPopOrderBy>;
  var_samp?: InputMaybe<NewsVarSampOrderBy>;
  variance?: InputMaybe<NewsVarianceOrderBy>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type NewsAppendInput = {
  keywords?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** input type for inserting array relation for remote table "news" */
export type NewsArrRelInsertInput = {
  data: Array<NewsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<NewsOnConflict>;
};

/** aggregate avg on columns */
export type NewsAvgFields = {
  __typename?: "news_avg_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  content_source_id?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  hash?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "news" */
export type NewsAvgOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  content_source_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "news". All fields are combined with a logical 'AND'. */
export type NewsBoolExp = {
  _and?: InputMaybe<Array<NewsBoolExp>>;
  _not?: InputMaybe<NewsBoolExp>;
  _or?: InputMaybe<Array<NewsBoolExp>>;
  author?: InputMaybe<StringComparisonExp>;
  body?: InputMaybe<StringComparisonExp>;
  category?: InputMaybe<CategoriesBoolExp>;
  category_id?: InputMaybe<BigintComparisonExp>;
  company?: InputMaybe<CompaniesBoolExp>;
  company_id?: InputMaybe<UuidComparisonExp>;
  content?: InputMaybe<ContentsBoolExp>;
  content_source?: InputMaybe<ContentSourcesBoolExp>;
  content_source_id?: InputMaybe<BigintComparisonExp>;
  content_status?: InputMaybe<ContentStatusComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  description?: InputMaybe<StringComparisonExp>;
  failed_count?: InputMaybe<SmallintComparisonExp>;
  featured_image?: InputMaybe<StringComparisonExp>;
  has_summary?: InputMaybe<BooleanComparisonExp>;
  hash?: InputMaybe<BigintComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  keywords?: InputMaybe<JsonbComparisonExp>;
  news_summaries?: InputMaybe<NewsSummariesBoolExp>;
  news_summaries_aggregate?: InputMaybe<NewsSummariesAggregateBoolExp>;
  published_at?: InputMaybe<TimestamptzComparisonExp>;
  scrape_frequency?: InputMaybe<ScrapeFrequencyComparisonExp>;
  scraped_at?: InputMaybe<TimestamptzComparisonExp>;
  title?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  url?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "news" */
export enum NewsConstraint {
  /** unique or primary key constraint on columns "id" */
  NEWS_ID_KEY = "news_id_key",
  /** unique or primary key constraint on columns "id" */
  NEWS_PKEY = "news_pkey",
  /** unique or primary key constraint on columns "url" */
  NEWS_URL_KEY = "news_url_key",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type NewsDeleteAtPathInput = {
  keywords?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type NewsDeleteElemInput = {
  keywords?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type NewsDeleteKeyInput = {
  keywords?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "news_details" */
export type NewsDetails = {
  __typename?: "news_details";
  author?: Maybe<Scalars["String"]["output"]>;
  bookmark_count?: Maybe<Scalars["bigint"]["output"]>;
  categories?: Maybe<Scalars["jsonb"]["output"]>;
  company_logo?: Maybe<Scalars["String"]["output"]>;
  company_name?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  featured_image?: Maybe<Scalars["String"]["output"]>;
  hot_score?: Maybe<Scalars["float8"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  summaries?: Maybe<Scalars["jsonb"]["output"]>;
  tags?: Maybe<Scalars["jsonb"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
  vote_count?: Maybe<Scalars["bigint"]["output"]>;
};

/** columns and relationships of "news_details" */
export type NewsDetailsCategoriesArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "news_details" */
export type NewsDetailsSummariesArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "news_details" */
export type NewsDetailsTagsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "news_details" */
export type NewsDetailsAggregate = {
  __typename?: "news_details_aggregate";
  aggregate?: Maybe<NewsDetailsAggregateFields>;
  nodes: Array<NewsDetails>;
};

/** aggregate fields of "news_details" */
export type NewsDetailsAggregateFields = {
  __typename?: "news_details_aggregate_fields";
  avg?: Maybe<NewsDetailsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<NewsDetailsMaxFields>;
  min?: Maybe<NewsDetailsMinFields>;
  stddev?: Maybe<NewsDetailsStddevFields>;
  stddev_pop?: Maybe<NewsDetailsStddevPopFields>;
  stddev_samp?: Maybe<NewsDetailsStddevSampFields>;
  sum?: Maybe<NewsDetailsSumFields>;
  var_pop?: Maybe<NewsDetailsVarPopFields>;
  var_samp?: Maybe<NewsDetailsVarSampFields>;
  variance?: Maybe<NewsDetailsVarianceFields>;
};

/** aggregate fields of "news_details" */
export type NewsDetailsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<NewsDetailsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type NewsDetailsAvgFields = {
  __typename?: "news_details_avg_fields";
  bookmark_count?: Maybe<Scalars["Float"]["output"]>;
  hot_score?: Maybe<Scalars["Float"]["output"]>;
  vote_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "news_details". All fields are combined with a logical 'AND'. */
export type NewsDetailsBoolExp = {
  _and?: InputMaybe<Array<NewsDetailsBoolExp>>;
  _not?: InputMaybe<NewsDetailsBoolExp>;
  _or?: InputMaybe<Array<NewsDetailsBoolExp>>;
  author?: InputMaybe<StringComparisonExp>;
  bookmark_count?: InputMaybe<BigintComparisonExp>;
  categories?: InputMaybe<JsonbComparisonExp>;
  company_logo?: InputMaybe<StringComparisonExp>;
  company_name?: InputMaybe<StringComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  description?: InputMaybe<StringComparisonExp>;
  featured_image?: InputMaybe<StringComparisonExp>;
  hot_score?: InputMaybe<Float8ComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  published_at?: InputMaybe<TimestamptzComparisonExp>;
  summaries?: InputMaybe<JsonbComparisonExp>;
  tags?: InputMaybe<JsonbComparisonExp>;
  title?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  url?: InputMaybe<StringComparisonExp>;
  vote_count?: InputMaybe<BigintComparisonExp>;
};

/** aggregate max on columns */
export type NewsDetailsMaxFields = {
  __typename?: "news_details_max_fields";
  author?: Maybe<Scalars["String"]["output"]>;
  bookmark_count?: Maybe<Scalars["bigint"]["output"]>;
  company_logo?: Maybe<Scalars["String"]["output"]>;
  company_name?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  featured_image?: Maybe<Scalars["String"]["output"]>;
  hot_score?: Maybe<Scalars["float8"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
  vote_count?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate min on columns */
export type NewsDetailsMinFields = {
  __typename?: "news_details_min_fields";
  author?: Maybe<Scalars["String"]["output"]>;
  bookmark_count?: Maybe<Scalars["bigint"]["output"]>;
  company_logo?: Maybe<Scalars["String"]["output"]>;
  company_name?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  featured_image?: Maybe<Scalars["String"]["output"]>;
  hot_score?: Maybe<Scalars["float8"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
  vote_count?: Maybe<Scalars["bigint"]["output"]>;
};

/** Ordering options when selecting data from "news_details". */
export type NewsDetailsOrderBy = {
  author?: InputMaybe<OrderBy>;
  bookmark_count?: InputMaybe<OrderBy>;
  categories?: InputMaybe<OrderBy>;
  company_logo?: InputMaybe<OrderBy>;
  company_name?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  description?: InputMaybe<OrderBy>;
  featured_image?: InputMaybe<OrderBy>;
  hot_score?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  published_at?: InputMaybe<OrderBy>;
  summaries?: InputMaybe<OrderBy>;
  tags?: InputMaybe<OrderBy>;
  title?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
  vote_count?: InputMaybe<OrderBy>;
};

/** select columns of table "news_details" */
export enum NewsDetailsSelectColumn {
  /** column name */
  AUTHOR = "author",
  /** column name */
  BOOKMARK_COUNT = "bookmark_count",
  /** column name */
  CATEGORIES = "categories",
  /** column name */
  COMPANY_LOGO = "company_logo",
  /** column name */
  COMPANY_NAME = "company_name",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  FEATURED_IMAGE = "featured_image",
  /** column name */
  HOT_SCORE = "hot_score",
  /** column name */
  ID = "id",
  /** column name */
  PUBLISHED_AT = "published_at",
  /** column name */
  SUMMARIES = "summaries",
  /** column name */
  TAGS = "tags",
  /** column name */
  TITLE = "title",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
  /** column name */
  VOTE_COUNT = "vote_count",
}

/** aggregate stddev on columns */
export type NewsDetailsStddevFields = {
  __typename?: "news_details_stddev_fields";
  bookmark_count?: Maybe<Scalars["Float"]["output"]>;
  hot_score?: Maybe<Scalars["Float"]["output"]>;
  vote_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type NewsDetailsStddevPopFields = {
  __typename?: "news_details_stddev_pop_fields";
  bookmark_count?: Maybe<Scalars["Float"]["output"]>;
  hot_score?: Maybe<Scalars["Float"]["output"]>;
  vote_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type NewsDetailsStddevSampFields = {
  __typename?: "news_details_stddev_samp_fields";
  bookmark_count?: Maybe<Scalars["Float"]["output"]>;
  hot_score?: Maybe<Scalars["Float"]["output"]>;
  vote_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "news_details" */
export type NewsDetailsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: NewsDetailsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type NewsDetailsStreamCursorValueInput = {
  author?: InputMaybe<Scalars["String"]["input"]>;
  bookmark_count?: InputMaybe<Scalars["bigint"]["input"]>;
  categories?: InputMaybe<Scalars["jsonb"]["input"]>;
  company_logo?: InputMaybe<Scalars["String"]["input"]>;
  company_name?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  featured_image?: InputMaybe<Scalars["String"]["input"]>;
  hot_score?: InputMaybe<Scalars["float8"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  published_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  summaries?: InputMaybe<Scalars["jsonb"]["input"]>;
  tags?: InputMaybe<Scalars["jsonb"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
  vote_count?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** aggregate sum on columns */
export type NewsDetailsSumFields = {
  __typename?: "news_details_sum_fields";
  bookmark_count?: Maybe<Scalars["bigint"]["output"]>;
  hot_score?: Maybe<Scalars["float8"]["output"]>;
  vote_count?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate var_pop on columns */
export type NewsDetailsVarPopFields = {
  __typename?: "news_details_var_pop_fields";
  bookmark_count?: Maybe<Scalars["Float"]["output"]>;
  hot_score?: Maybe<Scalars["Float"]["output"]>;
  vote_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type NewsDetailsVarSampFields = {
  __typename?: "news_details_var_samp_fields";
  bookmark_count?: Maybe<Scalars["Float"]["output"]>;
  hot_score?: Maybe<Scalars["Float"]["output"]>;
  vote_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type NewsDetailsVarianceFields = {
  __typename?: "news_details_variance_fields";
  bookmark_count?: Maybe<Scalars["Float"]["output"]>;
  hot_score?: Maybe<Scalars["Float"]["output"]>;
  vote_count?: Maybe<Scalars["Float"]["output"]>;
};

/** input type for incrementing numeric columns in table "news" */
export type NewsIncInput = {
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
  failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  hash?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** input type for inserting data into table "news" */
export type NewsInsertInput = {
  author?: InputMaybe<Scalars["String"]["input"]>;
  body?: InputMaybe<Scalars["String"]["input"]>;
  category?: InputMaybe<CategoriesObjRelInsertInput>;
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  company?: InputMaybe<CompaniesObjRelInsertInput>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content?: InputMaybe<ContentsObjRelInsertInput>;
  content_source?: InputMaybe<ContentSourcesObjRelInsertInput>;
  content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
  content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  featured_image?: InputMaybe<Scalars["String"]["input"]>;
  has_summary?: InputMaybe<Scalars["Boolean"]["input"]>;
  hash?: InputMaybe<Scalars["bigint"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  keywords?: InputMaybe<Scalars["jsonb"]["input"]>;
  news_summaries?: InputMaybe<NewsSummariesArrRelInsertInput>;
  published_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  scrape_frequency?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  scraped_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type NewsMaxFields = {
  __typename?: "news_max_fields";
  author?: Maybe<Scalars["String"]["output"]>;
  body?: Maybe<Scalars["String"]["output"]>;
  category_id?: Maybe<Scalars["bigint"]["output"]>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  content_status?: Maybe<Scalars["content_status"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  failed_count?: Maybe<Scalars["smallint"]["output"]>;
  featured_image?: Maybe<Scalars["String"]["output"]>;
  hash?: Maybe<Scalars["bigint"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  scrape_frequency?: Maybe<Scalars["scrape_frequency"]["output"]>;
  scraped_at?: Maybe<Scalars["timestamptz"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** order by max() on columns of table "news" */
export type NewsMaxOrderBy = {
  author?: InputMaybe<OrderBy>;
  body?: InputMaybe<OrderBy>;
  category_id?: InputMaybe<OrderBy>;
  company_id?: InputMaybe<OrderBy>;
  content_source_id?: InputMaybe<OrderBy>;
  content_status?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  description?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  featured_image?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  published_at?: InputMaybe<OrderBy>;
  scrape_frequency?: InputMaybe<OrderBy>;
  scraped_at?: InputMaybe<OrderBy>;
  title?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type NewsMinFields = {
  __typename?: "news_min_fields";
  author?: Maybe<Scalars["String"]["output"]>;
  body?: Maybe<Scalars["String"]["output"]>;
  category_id?: Maybe<Scalars["bigint"]["output"]>;
  company_id?: Maybe<Scalars["uuid"]["output"]>;
  content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  content_status?: Maybe<Scalars["content_status"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  description?: Maybe<Scalars["String"]["output"]>;
  failed_count?: Maybe<Scalars["smallint"]["output"]>;
  featured_image?: Maybe<Scalars["String"]["output"]>;
  hash?: Maybe<Scalars["bigint"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  scrape_frequency?: Maybe<Scalars["scrape_frequency"]["output"]>;
  scraped_at?: Maybe<Scalars["timestamptz"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** order by min() on columns of table "news" */
export type NewsMinOrderBy = {
  author?: InputMaybe<OrderBy>;
  body?: InputMaybe<OrderBy>;
  category_id?: InputMaybe<OrderBy>;
  company_id?: InputMaybe<OrderBy>;
  content_source_id?: InputMaybe<OrderBy>;
  content_status?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  description?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  featured_image?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  published_at?: InputMaybe<OrderBy>;
  scrape_frequency?: InputMaybe<OrderBy>;
  scraped_at?: InputMaybe<OrderBy>;
  title?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "news" */
export type NewsMutationResponse = {
  __typename?: "news_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<News>;
};

/** input type for inserting object relation for remote table "news" */
export type NewsObjRelInsertInput = {
  data: NewsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<NewsOnConflict>;
};

/** on_conflict condition type for table "news" */
export type NewsOnConflict = {
  constraint: NewsConstraint;
  update_columns?: Array<NewsUpdateColumn>;
  where?: InputMaybe<NewsBoolExp>;
};

/** Ordering options when selecting data from "news". */
export type NewsOrderBy = {
  author?: InputMaybe<OrderBy>;
  body?: InputMaybe<OrderBy>;
  category?: InputMaybe<CategoriesOrderBy>;
  category_id?: InputMaybe<OrderBy>;
  company?: InputMaybe<CompaniesOrderBy>;
  company_id?: InputMaybe<OrderBy>;
  content?: InputMaybe<ContentsOrderBy>;
  content_source?: InputMaybe<ContentSourcesOrderBy>;
  content_source_id?: InputMaybe<OrderBy>;
  content_status?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  description?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  featured_image?: InputMaybe<OrderBy>;
  has_summary?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  keywords?: InputMaybe<OrderBy>;
  news_summaries_aggregate?: InputMaybe<NewsSummariesAggregateOrderBy>;
  published_at?: InputMaybe<OrderBy>;
  scrape_frequency?: InputMaybe<OrderBy>;
  scraped_at?: InputMaybe<OrderBy>;
  title?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: news */
export type NewsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type NewsPrependInput = {
  keywords?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "news" */
export enum NewsSelectColumn {
  /** column name */
  AUTHOR = "author",
  /** column name */
  BODY = "body",
  /** column name */
  CATEGORY_ID = "category_id",
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CONTENT_SOURCE_ID = "content_source_id",
  /** column name */
  CONTENT_STATUS = "content_status",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  FAILED_COUNT = "failed_count",
  /** column name */
  FEATURED_IMAGE = "featured_image",
  /** column name */
  HAS_SUMMARY = "has_summary",
  /** column name */
  HASH = "hash",
  /** column name */
  ID = "id",
  /** column name */
  KEYWORDS = "keywords",
  /** column name */
  PUBLISHED_AT = "published_at",
  /** column name */
  SCRAPE_FREQUENCY = "scrape_frequency",
  /** column name */
  SCRAPED_AT = "scraped_at",
  /** column name */
  TITLE = "title",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
}

/** select "news_aggregate_bool_exp_bool_and_arguments_columns" columns of table "news" */
export enum NewsSelectColumnNewsAggregateBoolExpBoolAndArgumentsColumns {
  /** column name */
  HAS_SUMMARY = "has_summary",
}

/** select "news_aggregate_bool_exp_bool_or_arguments_columns" columns of table "news" */
export enum NewsSelectColumnNewsAggregateBoolExpBoolOrArgumentsColumns {
  /** column name */
  HAS_SUMMARY = "has_summary",
}

/** input type for updating data in table "news" */
export type NewsSetInput = {
  author?: InputMaybe<Scalars["String"]["input"]>;
  body?: InputMaybe<Scalars["String"]["input"]>;
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
  content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  featured_image?: InputMaybe<Scalars["String"]["input"]>;
  has_summary?: InputMaybe<Scalars["Boolean"]["input"]>;
  hash?: InputMaybe<Scalars["bigint"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  keywords?: InputMaybe<Scalars["jsonb"]["input"]>;
  published_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  scrape_frequency?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  scraped_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type NewsStddevFields = {
  __typename?: "news_stddev_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  content_source_id?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  hash?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "news" */
export type NewsStddevOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  content_source_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type NewsStddevPopFields = {
  __typename?: "news_stddev_pop_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  content_source_id?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  hash?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "news" */
export type NewsStddevPopOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  content_source_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type NewsStddevSampFields = {
  __typename?: "news_stddev_samp_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  content_source_id?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  hash?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "news" */
export type NewsStddevSampOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  content_source_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "news" */
export type NewsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: NewsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type NewsStreamCursorValueInput = {
  author?: InputMaybe<Scalars["String"]["input"]>;
  body?: InputMaybe<Scalars["String"]["input"]>;
  category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
  content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  description?: InputMaybe<Scalars["String"]["input"]>;
  failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  featured_image?: InputMaybe<Scalars["String"]["input"]>;
  has_summary?: InputMaybe<Scalars["Boolean"]["input"]>;
  hash?: InputMaybe<Scalars["bigint"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  keywords?: InputMaybe<Scalars["jsonb"]["input"]>;
  published_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  scrape_frequency?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  scraped_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type NewsSumFields = {
  __typename?: "news_sum_fields";
  category_id?: Maybe<Scalars["bigint"]["output"]>;
  content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  failed_count?: Maybe<Scalars["smallint"]["output"]>;
  hash?: Maybe<Scalars["bigint"]["output"]>;
};

/** order by sum() on columns of table "news" */
export type NewsSumOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  content_source_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
};

/** columns and relationships of "news_summaries" */
export type NewsSummaries = {
  __typename?: "news_summaries";
  complexity_level?: Maybe<Scalars["complexity_level"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  embedding?: Maybe<Scalars["vector"]["output"]>;
  id: Scalars["uuid"]["output"];
  is_current?: Maybe<Scalars["Boolean"]["output"]>;
  /** An object relationship */
  news: News;
  news_id: Scalars["uuid"]["output"];
  summary?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  version: Scalars["Int"]["output"];
};

/** aggregated selection of "news_summaries" */
export type NewsSummariesAggregate = {
  __typename?: "news_summaries_aggregate";
  aggregate?: Maybe<NewsSummariesAggregateFields>;
  nodes: Array<NewsSummaries>;
};

export type NewsSummariesAggregateBoolExp = {
  bool_and?: InputMaybe<NewsSummariesAggregateBoolExpBoolAnd>;
  bool_or?: InputMaybe<NewsSummariesAggregateBoolExpBoolOr>;
  count?: InputMaybe<NewsSummariesAggregateBoolExpCount>;
};

export type NewsSummariesAggregateBoolExpBoolAnd = {
  arguments: NewsSummariesSelectColumnNewsSummariesAggregateBoolExpBoolAndArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<NewsSummariesBoolExp>;
  predicate: BooleanComparisonExp;
};

export type NewsSummariesAggregateBoolExpBoolOr = {
  arguments: NewsSummariesSelectColumnNewsSummariesAggregateBoolExpBoolOrArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<NewsSummariesBoolExp>;
  predicate: BooleanComparisonExp;
};

export type NewsSummariesAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<NewsSummariesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<NewsSummariesBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "news_summaries" */
export type NewsSummariesAggregateFields = {
  __typename?: "news_summaries_aggregate_fields";
  avg?: Maybe<NewsSummariesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<NewsSummariesMaxFields>;
  min?: Maybe<NewsSummariesMinFields>;
  stddev?: Maybe<NewsSummariesStddevFields>;
  stddev_pop?: Maybe<NewsSummariesStddevPopFields>;
  stddev_samp?: Maybe<NewsSummariesStddevSampFields>;
  sum?: Maybe<NewsSummariesSumFields>;
  var_pop?: Maybe<NewsSummariesVarPopFields>;
  var_samp?: Maybe<NewsSummariesVarSampFields>;
  variance?: Maybe<NewsSummariesVarianceFields>;
};

/** aggregate fields of "news_summaries" */
export type NewsSummariesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<NewsSummariesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "news_summaries" */
export type NewsSummariesAggregateOrderBy = {
  avg?: InputMaybe<NewsSummariesAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<NewsSummariesMaxOrderBy>;
  min?: InputMaybe<NewsSummariesMinOrderBy>;
  stddev?: InputMaybe<NewsSummariesStddevOrderBy>;
  stddev_pop?: InputMaybe<NewsSummariesStddevPopOrderBy>;
  stddev_samp?: InputMaybe<NewsSummariesStddevSampOrderBy>;
  sum?: InputMaybe<NewsSummariesSumOrderBy>;
  var_pop?: InputMaybe<NewsSummariesVarPopOrderBy>;
  var_samp?: InputMaybe<NewsSummariesVarSampOrderBy>;
  variance?: InputMaybe<NewsSummariesVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "news_summaries" */
export type NewsSummariesArrRelInsertInput = {
  data: Array<NewsSummariesInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<NewsSummariesOnConflict>;
};

/** aggregate avg on columns */
export type NewsSummariesAvgFields = {
  __typename?: "news_summaries_avg_fields";
  version?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "news_summaries" */
export type NewsSummariesAvgOrderBy = {
  version?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "news_summaries". All fields are combined with a logical 'AND'. */
export type NewsSummariesBoolExp = {
  _and?: InputMaybe<Array<NewsSummariesBoolExp>>;
  _not?: InputMaybe<NewsSummariesBoolExp>;
  _or?: InputMaybe<Array<NewsSummariesBoolExp>>;
  complexity_level?: InputMaybe<ComplexityLevelComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  embedding?: InputMaybe<VectorComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  is_current?: InputMaybe<BooleanComparisonExp>;
  news?: InputMaybe<NewsBoolExp>;
  news_id?: InputMaybe<UuidComparisonExp>;
  summary?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  version?: InputMaybe<IntComparisonExp>;
};

/** unique or primary key constraints on table "news_summaries" */
export enum NewsSummariesConstraint {
  /** unique or primary key constraint on columns "id" */
  NEWS_SUMMARIES_PKEY = "news_summaries_pkey",
}

/** input type for incrementing numeric columns in table "news_summaries" */
export type NewsSummariesIncInput = {
  version?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "news_summaries" */
export type NewsSummariesInsertInput = {
  complexity_level?: InputMaybe<Scalars["complexity_level"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  embedding?: InputMaybe<Scalars["vector"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_current?: InputMaybe<Scalars["Boolean"]["input"]>;
  news?: InputMaybe<NewsObjRelInsertInput>;
  news_id?: InputMaybe<Scalars["uuid"]["input"]>;
  summary?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  version?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate max on columns */
export type NewsSummariesMaxFields = {
  __typename?: "news_summaries_max_fields";
  complexity_level?: Maybe<Scalars["complexity_level"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  news_id?: Maybe<Scalars["uuid"]["output"]>;
  summary?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  version?: Maybe<Scalars["Int"]["output"]>;
};

/** order by max() on columns of table "news_summaries" */
export type NewsSummariesMaxOrderBy = {
  complexity_level?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  news_id?: InputMaybe<OrderBy>;
  summary?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  version?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type NewsSummariesMinFields = {
  __typename?: "news_summaries_min_fields";
  complexity_level?: Maybe<Scalars["complexity_level"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  news_id?: Maybe<Scalars["uuid"]["output"]>;
  summary?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  version?: Maybe<Scalars["Int"]["output"]>;
};

/** order by min() on columns of table "news_summaries" */
export type NewsSummariesMinOrderBy = {
  complexity_level?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  news_id?: InputMaybe<OrderBy>;
  summary?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  version?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "news_summaries" */
export type NewsSummariesMutationResponse = {
  __typename?: "news_summaries_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<NewsSummaries>;
};

/** on_conflict condition type for table "news_summaries" */
export type NewsSummariesOnConflict = {
  constraint: NewsSummariesConstraint;
  update_columns?: Array<NewsSummariesUpdateColumn>;
  where?: InputMaybe<NewsSummariesBoolExp>;
};

/** Ordering options when selecting data from "news_summaries". */
export type NewsSummariesOrderBy = {
  complexity_level?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  embedding?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  is_current?: InputMaybe<OrderBy>;
  news?: InputMaybe<NewsOrderBy>;
  news_id?: InputMaybe<OrderBy>;
  summary?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  version?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: news_summaries */
export type NewsSummariesPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "news_summaries" */
export enum NewsSummariesSelectColumn {
  /** column name */
  COMPLEXITY_LEVEL = "complexity_level",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  EMBEDDING = "embedding",
  /** column name */
  ID = "id",
  /** column name */
  IS_CURRENT = "is_current",
  /** column name */
  NEWS_ID = "news_id",
  /** column name */
  SUMMARY = "summary",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  VERSION = "version",
}

/** select "news_summaries_aggregate_bool_exp_bool_and_arguments_columns" columns of table "news_summaries" */
export enum NewsSummariesSelectColumnNewsSummariesAggregateBoolExpBoolAndArgumentsColumns {
  /** column name */
  IS_CURRENT = "is_current",
}

/** select "news_summaries_aggregate_bool_exp_bool_or_arguments_columns" columns of table "news_summaries" */
export enum NewsSummariesSelectColumnNewsSummariesAggregateBoolExpBoolOrArgumentsColumns {
  /** column name */
  IS_CURRENT = "is_current",
}

/** input type for updating data in table "news_summaries" */
export type NewsSummariesSetInput = {
  complexity_level?: InputMaybe<Scalars["complexity_level"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  embedding?: InputMaybe<Scalars["vector"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_current?: InputMaybe<Scalars["Boolean"]["input"]>;
  news_id?: InputMaybe<Scalars["uuid"]["input"]>;
  summary?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  version?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate stddev on columns */
export type NewsSummariesStddevFields = {
  __typename?: "news_summaries_stddev_fields";
  version?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "news_summaries" */
export type NewsSummariesStddevOrderBy = {
  version?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type NewsSummariesStddevPopFields = {
  __typename?: "news_summaries_stddev_pop_fields";
  version?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "news_summaries" */
export type NewsSummariesStddevPopOrderBy = {
  version?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type NewsSummariesStddevSampFields = {
  __typename?: "news_summaries_stddev_samp_fields";
  version?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "news_summaries" */
export type NewsSummariesStddevSampOrderBy = {
  version?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "news_summaries" */
export type NewsSummariesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: NewsSummariesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type NewsSummariesStreamCursorValueInput = {
  complexity_level?: InputMaybe<Scalars["complexity_level"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  embedding?: InputMaybe<Scalars["vector"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_current?: InputMaybe<Scalars["Boolean"]["input"]>;
  news_id?: InputMaybe<Scalars["uuid"]["input"]>;
  summary?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  version?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate sum on columns */
export type NewsSummariesSumFields = {
  __typename?: "news_summaries_sum_fields";
  version?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "news_summaries" */
export type NewsSummariesSumOrderBy = {
  version?: InputMaybe<OrderBy>;
};

/** update columns of table "news_summaries" */
export enum NewsSummariesUpdateColumn {
  /** column name */
  COMPLEXITY_LEVEL = "complexity_level",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  EMBEDDING = "embedding",
  /** column name */
  ID = "id",
  /** column name */
  IS_CURRENT = "is_current",
  /** column name */
  NEWS_ID = "news_id",
  /** column name */
  SUMMARY = "summary",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  VERSION = "version",
}

export type NewsSummariesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<NewsSummariesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<NewsSummariesSetInput>;
  /** filter the rows which have to be updated */
  where: NewsSummariesBoolExp;
};

/** aggregate var_pop on columns */
export type NewsSummariesVarPopFields = {
  __typename?: "news_summaries_var_pop_fields";
  version?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "news_summaries" */
export type NewsSummariesVarPopOrderBy = {
  version?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type NewsSummariesVarSampFields = {
  __typename?: "news_summaries_var_samp_fields";
  version?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "news_summaries" */
export type NewsSummariesVarSampOrderBy = {
  version?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type NewsSummariesVarianceFields = {
  __typename?: "news_summaries_variance_fields";
  version?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "news_summaries" */
export type NewsSummariesVarianceOrderBy = {
  version?: InputMaybe<OrderBy>;
};

/** columns and relationships of "news_tags" */
export type NewsTags = {
  __typename?: "news_tags";
  id: Scalars["Int"]["output"];
  news_id?: Maybe<Scalars["uuid"]["output"]>;
  /** An object relationship */
  tag: Tags;
  tag_id: Scalars["Int"]["output"];
};

/** aggregated selection of "news_tags" */
export type NewsTagsAggregate = {
  __typename?: "news_tags_aggregate";
  aggregate?: Maybe<NewsTagsAggregateFields>;
  nodes: Array<NewsTags>;
};

export type NewsTagsAggregateBoolExp = {
  count?: InputMaybe<NewsTagsAggregateBoolExpCount>;
};

export type NewsTagsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<NewsTagsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<NewsTagsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "news_tags" */
export type NewsTagsAggregateFields = {
  __typename?: "news_tags_aggregate_fields";
  avg?: Maybe<NewsTagsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<NewsTagsMaxFields>;
  min?: Maybe<NewsTagsMinFields>;
  stddev?: Maybe<NewsTagsStddevFields>;
  stddev_pop?: Maybe<NewsTagsStddevPopFields>;
  stddev_samp?: Maybe<NewsTagsStddevSampFields>;
  sum?: Maybe<NewsTagsSumFields>;
  var_pop?: Maybe<NewsTagsVarPopFields>;
  var_samp?: Maybe<NewsTagsVarSampFields>;
  variance?: Maybe<NewsTagsVarianceFields>;
};

/** aggregate fields of "news_tags" */
export type NewsTagsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<NewsTagsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "news_tags" */
export type NewsTagsAggregateOrderBy = {
  avg?: InputMaybe<NewsTagsAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<NewsTagsMaxOrderBy>;
  min?: InputMaybe<NewsTagsMinOrderBy>;
  stddev?: InputMaybe<NewsTagsStddevOrderBy>;
  stddev_pop?: InputMaybe<NewsTagsStddevPopOrderBy>;
  stddev_samp?: InputMaybe<NewsTagsStddevSampOrderBy>;
  sum?: InputMaybe<NewsTagsSumOrderBy>;
  var_pop?: InputMaybe<NewsTagsVarPopOrderBy>;
  var_samp?: InputMaybe<NewsTagsVarSampOrderBy>;
  variance?: InputMaybe<NewsTagsVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "news_tags" */
export type NewsTagsArrRelInsertInput = {
  data: Array<NewsTagsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<NewsTagsOnConflict>;
};

/** aggregate avg on columns */
export type NewsTagsAvgFields = {
  __typename?: "news_tags_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  tag_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "news_tags" */
export type NewsTagsAvgOrderBy = {
  id?: InputMaybe<OrderBy>;
  tag_id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "news_tags". All fields are combined with a logical 'AND'. */
export type NewsTagsBoolExp = {
  _and?: InputMaybe<Array<NewsTagsBoolExp>>;
  _not?: InputMaybe<NewsTagsBoolExp>;
  _or?: InputMaybe<Array<NewsTagsBoolExp>>;
  id?: InputMaybe<IntComparisonExp>;
  news_id?: InputMaybe<UuidComparisonExp>;
  tag?: InputMaybe<TagsBoolExp>;
  tag_id?: InputMaybe<IntComparisonExp>;
};

/** unique or primary key constraints on table "news_tags" */
export enum NewsTagsConstraint {
  /** unique or primary key constraint on columns "id" */
  NEWS_TAGS_PKEY = "news_tags_pkey",
}

/** input type for incrementing numeric columns in table "news_tags" */
export type NewsTagsIncInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
  tag_id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "news_tags" */
export type NewsTagsInsertInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
  news_id?: InputMaybe<Scalars["uuid"]["input"]>;
  tag?: InputMaybe<TagsObjRelInsertInput>;
  tag_id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate max on columns */
export type NewsTagsMaxFields = {
  __typename?: "news_tags_max_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
  news_id?: Maybe<Scalars["uuid"]["output"]>;
  tag_id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by max() on columns of table "news_tags" */
export type NewsTagsMaxOrderBy = {
  id?: InputMaybe<OrderBy>;
  news_id?: InputMaybe<OrderBy>;
  tag_id?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type NewsTagsMinFields = {
  __typename?: "news_tags_min_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
  news_id?: Maybe<Scalars["uuid"]["output"]>;
  tag_id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by min() on columns of table "news_tags" */
export type NewsTagsMinOrderBy = {
  id?: InputMaybe<OrderBy>;
  news_id?: InputMaybe<OrderBy>;
  tag_id?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "news_tags" */
export type NewsTagsMutationResponse = {
  __typename?: "news_tags_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<NewsTags>;
};

/** on_conflict condition type for table "news_tags" */
export type NewsTagsOnConflict = {
  constraint: NewsTagsConstraint;
  update_columns?: Array<NewsTagsUpdateColumn>;
  where?: InputMaybe<NewsTagsBoolExp>;
};

/** Ordering options when selecting data from "news_tags". */
export type NewsTagsOrderBy = {
  id?: InputMaybe<OrderBy>;
  news_id?: InputMaybe<OrderBy>;
  tag?: InputMaybe<TagsOrderBy>;
  tag_id?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: news_tags */
export type NewsTagsPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "news_tags" */
export enum NewsTagsSelectColumn {
  /** column name */
  ID = "id",
  /** column name */
  NEWS_ID = "news_id",
  /** column name */
  TAG_ID = "tag_id",
}

/** input type for updating data in table "news_tags" */
export type NewsTagsSetInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
  news_id?: InputMaybe<Scalars["uuid"]["input"]>;
  tag_id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate stddev on columns */
export type NewsTagsStddevFields = {
  __typename?: "news_tags_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  tag_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "news_tags" */
export type NewsTagsStddevOrderBy = {
  id?: InputMaybe<OrderBy>;
  tag_id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type NewsTagsStddevPopFields = {
  __typename?: "news_tags_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  tag_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "news_tags" */
export type NewsTagsStddevPopOrderBy = {
  id?: InputMaybe<OrderBy>;
  tag_id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type NewsTagsStddevSampFields = {
  __typename?: "news_tags_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  tag_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "news_tags" */
export type NewsTagsStddevSampOrderBy = {
  id?: InputMaybe<OrderBy>;
  tag_id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "news_tags" */
export type NewsTagsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: NewsTagsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type NewsTagsStreamCursorValueInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
  news_id?: InputMaybe<Scalars["uuid"]["input"]>;
  tag_id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate sum on columns */
export type NewsTagsSumFields = {
  __typename?: "news_tags_sum_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
  tag_id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "news_tags" */
export type NewsTagsSumOrderBy = {
  id?: InputMaybe<OrderBy>;
  tag_id?: InputMaybe<OrderBy>;
};

/** update columns of table "news_tags" */
export enum NewsTagsUpdateColumn {
  /** column name */
  ID = "id",
  /** column name */
  NEWS_ID = "news_id",
  /** column name */
  TAG_ID = "tag_id",
}

export type NewsTagsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<NewsTagsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<NewsTagsSetInput>;
  /** filter the rows which have to be updated */
  where: NewsTagsBoolExp;
};

/** aggregate var_pop on columns */
export type NewsTagsVarPopFields = {
  __typename?: "news_tags_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  tag_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "news_tags" */
export type NewsTagsVarPopOrderBy = {
  id?: InputMaybe<OrderBy>;
  tag_id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type NewsTagsVarSampFields = {
  __typename?: "news_tags_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  tag_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "news_tags" */
export type NewsTagsVarSampOrderBy = {
  id?: InputMaybe<OrderBy>;
  tag_id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type NewsTagsVarianceFields = {
  __typename?: "news_tags_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  tag_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "news_tags" */
export type NewsTagsVarianceOrderBy = {
  id?: InputMaybe<OrderBy>;
  tag_id?: InputMaybe<OrderBy>;
};

/** update columns of table "news" */
export enum NewsUpdateColumn {
  /** column name */
  AUTHOR = "author",
  /** column name */
  BODY = "body",
  /** column name */
  CATEGORY_ID = "category_id",
  /** column name */
  COMPANY_ID = "company_id",
  /** column name */
  CONTENT_SOURCE_ID = "content_source_id",
  /** column name */
  CONTENT_STATUS = "content_status",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  FAILED_COUNT = "failed_count",
  /** column name */
  FEATURED_IMAGE = "featured_image",
  /** column name */
  HAS_SUMMARY = "has_summary",
  /** column name */
  HASH = "hash",
  /** column name */
  ID = "id",
  /** column name */
  KEYWORDS = "keywords",
  /** column name */
  PUBLISHED_AT = "published_at",
  /** column name */
  SCRAPE_FREQUENCY = "scrape_frequency",
  /** column name */
  SCRAPED_AT = "scraped_at",
  /** column name */
  TITLE = "title",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
}

export type NewsUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<NewsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<NewsDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<NewsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<NewsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<NewsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<NewsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<NewsSetInput>;
  /** filter the rows which have to be updated */
  where: NewsBoolExp;
};

/** aggregate var_pop on columns */
export type NewsVarPopFields = {
  __typename?: "news_var_pop_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  content_source_id?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  hash?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "news" */
export type NewsVarPopOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  content_source_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type NewsVarSampFields = {
  __typename?: "news_var_samp_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  content_source_id?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  hash?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "news" */
export type NewsVarSampOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  content_source_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type NewsVarianceFields = {
  __typename?: "news_variance_fields";
  category_id?: Maybe<Scalars["Float"]["output"]>;
  content_source_id?: Maybe<Scalars["Float"]["output"]>;
  failed_count?: Maybe<Scalars["Float"]["output"]>;
  hash?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "news" */
export type NewsVarianceOrderBy = {
  category_id?: InputMaybe<OrderBy>;
  content_source_id?: InputMaybe<OrderBy>;
  failed_count?: InputMaybe<OrderBy>;
  hash?: InputMaybe<OrderBy>;
};

/** columns and relationships of "newsletters" */
export type Newsletters = {
  __typename?: "newsletters";
  /** An object relationship */
  content: Contents;
  content_status: Scalars["content_status"]["output"];
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  end_date: Scalars["timestamptz"]["output"];
  frequency: Scalars["String"]["output"];
  generated_content?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["uuid"]["output"];
  start_date: Scalars["timestamptz"]["output"];
  title: Scalars["String"]["output"];
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregated selection of "newsletters" */
export type NewslettersAggregate = {
  __typename?: "newsletters_aggregate";
  aggregate?: Maybe<NewslettersAggregateFields>;
  nodes: Array<Newsletters>;
};

/** aggregate fields of "newsletters" */
export type NewslettersAggregateFields = {
  __typename?: "newsletters_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<NewslettersMaxFields>;
  min?: Maybe<NewslettersMinFields>;
};

/** aggregate fields of "newsletters" */
export type NewslettersAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<NewslettersSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** Boolean expression to filter rows from the table "newsletters". All fields are combined with a logical 'AND'. */
export type NewslettersBoolExp = {
  _and?: InputMaybe<Array<NewslettersBoolExp>>;
  _not?: InputMaybe<NewslettersBoolExp>;
  _or?: InputMaybe<Array<NewslettersBoolExp>>;
  content?: InputMaybe<ContentsBoolExp>;
  content_status?: InputMaybe<ContentStatusComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  end_date?: InputMaybe<TimestamptzComparisonExp>;
  frequency?: InputMaybe<StringComparisonExp>;
  generated_content?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  start_date?: InputMaybe<TimestamptzComparisonExp>;
  title?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
};

/** unique or primary key constraints on table "newsletters" */
export enum NewslettersConstraint {
  /** unique or primary key constraint on columns "id" */
  NEWSLETTERS_PKEY = "newsletters_pkey",
}

/** input type for inserting data into table "newsletters" */
export type NewslettersInsertInput = {
  content?: InputMaybe<ContentsObjRelInsertInput>;
  content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  end_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  frequency?: InputMaybe<Scalars["String"]["input"]>;
  generated_content?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  start_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate max on columns */
export type NewslettersMaxFields = {
  __typename?: "newsletters_max_fields";
  content_status?: Maybe<Scalars["content_status"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  end_date?: Maybe<Scalars["timestamptz"]["output"]>;
  frequency?: Maybe<Scalars["String"]["output"]>;
  generated_content?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  start_date?: Maybe<Scalars["timestamptz"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregate min on columns */
export type NewslettersMinFields = {
  __typename?: "newsletters_min_fields";
  content_status?: Maybe<Scalars["content_status"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  end_date?: Maybe<Scalars["timestamptz"]["output"]>;
  frequency?: Maybe<Scalars["String"]["output"]>;
  generated_content?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  start_date?: Maybe<Scalars["timestamptz"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** response of any mutation on the table "newsletters" */
export type NewslettersMutationResponse = {
  __typename?: "newsletters_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Newsletters>;
};

/** input type for inserting object relation for remote table "newsletters" */
export type NewslettersObjRelInsertInput = {
  data: NewslettersInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<NewslettersOnConflict>;
};

/** on_conflict condition type for table "newsletters" */
export type NewslettersOnConflict = {
  constraint: NewslettersConstraint;
  update_columns?: Array<NewslettersUpdateColumn>;
  where?: InputMaybe<NewslettersBoolExp>;
};

/** Ordering options when selecting data from "newsletters". */
export type NewslettersOrderBy = {
  content?: InputMaybe<ContentsOrderBy>;
  content_status?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  end_date?: InputMaybe<OrderBy>;
  frequency?: InputMaybe<OrderBy>;
  generated_content?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  start_date?: InputMaybe<OrderBy>;
  title?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: newsletters */
export type NewslettersPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "newsletters" */
export enum NewslettersSelectColumn {
  /** column name */
  CONTENT_STATUS = "content_status",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  END_DATE = "end_date",
  /** column name */
  FREQUENCY = "frequency",
  /** column name */
  GENERATED_CONTENT = "generated_content",
  /** column name */
  ID = "id",
  /** column name */
  START_DATE = "start_date",
  /** column name */
  TITLE = "title",
  /** column name */
  UPDATED_AT = "updated_at",
}

/** input type for updating data in table "newsletters" */
export type NewslettersSetInput = {
  content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  end_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  frequency?: InputMaybe<Scalars["String"]["input"]>;
  generated_content?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  start_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** Streaming cursor of the table "newsletters" */
export type NewslettersStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: NewslettersStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type NewslettersStreamCursorValueInput = {
  content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  end_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  frequency?: InputMaybe<Scalars["String"]["input"]>;
  generated_content?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  start_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** update columns of table "newsletters" */
export enum NewslettersUpdateColumn {
  /** column name */
  CONTENT_STATUS = "content_status",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  END_DATE = "end_date",
  /** column name */
  FREQUENCY = "frequency",
  /** column name */
  GENERATED_CONTENT = "generated_content",
  /** column name */
  ID = "id",
  /** column name */
  START_DATE = "start_date",
  /** column name */
  TITLE = "title",
  /** column name */
  UPDATED_AT = "updated_at",
}

export type NewslettersUpdates = {
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<NewslettersSetInput>;
  /** filter the rows which have to be updated */
  where: NewslettersBoolExp;
};

/** Boolean expression to compare columns of type "numeric". All fields are combined with logical 'AND'. */
export type NumericComparisonExp = {
  _eq?: InputMaybe<Scalars["numeric"]["input"]>;
  _gt?: InputMaybe<Scalars["numeric"]["input"]>;
  _gte?: InputMaybe<Scalars["numeric"]["input"]>;
  _in?: InputMaybe<Array<Scalars["numeric"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["numeric"]["input"]>;
  _lte?: InputMaybe<Scalars["numeric"]["input"]>;
  _neq?: InputMaybe<Scalars["numeric"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["numeric"]["input"]>>;
};

/** column ordering options */
export enum OrderBy {
  /** in ascending order, nulls last */
  ASC = "asc",
  /** in ascending order, nulls first */
  ASC_NULLS_FIRST = "asc_nulls_first",
  /** in ascending order, nulls last */
  ASC_NULLS_LAST = "asc_nulls_last",
  /** in descending order, nulls first */
  DESC = "desc",
  /** in descending order, nulls first */
  DESC_NULLS_FIRST = "desc_nulls_first",
  /** in descending order, nulls last */
  DESC_NULLS_LAST = "desc_nulls_last",
}

/** columns and relationships of "payment_providers" */
export type PaymentProviders = {
  __typename?: "payment_providers";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  /** An array relationship */
  customer_payments: Array<CustomerPayments>;
  /** An aggregate relationship */
  customer_payments_aggregate: CustomerPaymentsAggregate;
  /** An array relationship */
  customer_subscriptions: Array<CustomerSubscriptions>;
  /** An aggregate relationship */
  customer_subscriptions_aggregate: CustomerSubscriptionsAggregate;
  id: Scalars["Int"]["output"];
  is_active?: Maybe<Scalars["Boolean"]["output"]>;
  name: Scalars["String"]["output"];
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** columns and relationships of "payment_providers" */
export type PaymentProvidersCustomerPaymentsArgs = {
  distinct_on?: InputMaybe<Array<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

/** columns and relationships of "payment_providers" */
export type PaymentProvidersCustomerPaymentsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

/** columns and relationships of "payment_providers" */
export type PaymentProvidersCustomerSubscriptionsArgs = {
  distinct_on?: InputMaybe<Array<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

/** columns and relationships of "payment_providers" */
export type PaymentProvidersCustomerSubscriptionsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

/** aggregated selection of "payment_providers" */
export type PaymentProvidersAggregate = {
  __typename?: "payment_providers_aggregate";
  aggregate?: Maybe<PaymentProvidersAggregateFields>;
  nodes: Array<PaymentProviders>;
};

/** aggregate fields of "payment_providers" */
export type PaymentProvidersAggregateFields = {
  __typename?: "payment_providers_aggregate_fields";
  avg?: Maybe<PaymentProvidersAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<PaymentProvidersMaxFields>;
  min?: Maybe<PaymentProvidersMinFields>;
  stddev?: Maybe<PaymentProvidersStddevFields>;
  stddev_pop?: Maybe<PaymentProvidersStddevPopFields>;
  stddev_samp?: Maybe<PaymentProvidersStddevSampFields>;
  sum?: Maybe<PaymentProvidersSumFields>;
  var_pop?: Maybe<PaymentProvidersVarPopFields>;
  var_samp?: Maybe<PaymentProvidersVarSampFields>;
  variance?: Maybe<PaymentProvidersVarianceFields>;
};

/** aggregate fields of "payment_providers" */
export type PaymentProvidersAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<PaymentProvidersSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type PaymentProvidersAvgFields = {
  __typename?: "payment_providers_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "payment_providers". All fields are combined with a logical 'AND'. */
export type PaymentProvidersBoolExp = {
  _and?: InputMaybe<Array<PaymentProvidersBoolExp>>;
  _not?: InputMaybe<PaymentProvidersBoolExp>;
  _or?: InputMaybe<Array<PaymentProvidersBoolExp>>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  customer_payments?: InputMaybe<CustomerPaymentsBoolExp>;
  customer_payments_aggregate?: InputMaybe<CustomerPaymentsAggregateBoolExp>;
  customer_subscriptions?: InputMaybe<CustomerSubscriptionsBoolExp>;
  customer_subscriptions_aggregate?: InputMaybe<CustomerSubscriptionsAggregateBoolExp>;
  id?: InputMaybe<IntComparisonExp>;
  is_active?: InputMaybe<BooleanComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
};

/** unique or primary key constraints on table "payment_providers" */
export enum PaymentProvidersConstraint {
  /** unique or primary key constraint on columns "name" */
  PAYMENT_PROVIDERS_NAME_KEY = "payment_providers_name_key",
  /** unique or primary key constraint on columns "id" */
  PAYMENT_PROVIDERS_PKEY = "payment_providers_pkey",
}

/** input type for incrementing numeric columns in table "payment_providers" */
export type PaymentProvidersIncInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "payment_providers" */
export type PaymentProvidersInsertInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  customer_payments?: InputMaybe<CustomerPaymentsArrRelInsertInput>;
  customer_subscriptions?: InputMaybe<CustomerSubscriptionsArrRelInsertInput>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate max on columns */
export type PaymentProvidersMaxFields = {
  __typename?: "payment_providers_max_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregate min on columns */
export type PaymentProvidersMinFields = {
  __typename?: "payment_providers_min_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** response of any mutation on the table "payment_providers" */
export type PaymentProvidersMutationResponse = {
  __typename?: "payment_providers_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<PaymentProviders>;
};

/** input type for inserting object relation for remote table "payment_providers" */
export type PaymentProvidersObjRelInsertInput = {
  data: PaymentProvidersInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<PaymentProvidersOnConflict>;
};

/** on_conflict condition type for table "payment_providers" */
export type PaymentProvidersOnConflict = {
  constraint: PaymentProvidersConstraint;
  update_columns?: Array<PaymentProvidersUpdateColumn>;
  where?: InputMaybe<PaymentProvidersBoolExp>;
};

/** Ordering options when selecting data from "payment_providers". */
export type PaymentProvidersOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  customer_payments_aggregate?: InputMaybe<CustomerPaymentsAggregateOrderBy>;
  customer_subscriptions_aggregate?: InputMaybe<CustomerSubscriptionsAggregateOrderBy>;
  id?: InputMaybe<OrderBy>;
  is_active?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: payment_providers */
export type PaymentProvidersPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "payment_providers" */
export enum PaymentProvidersSelectColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  IS_ACTIVE = "is_active",
  /** column name */
  NAME = "name",
  /** column name */
  UPDATED_AT = "updated_at",
}

/** input type for updating data in table "payment_providers" */
export type PaymentProvidersSetInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate stddev on columns */
export type PaymentProvidersStddevFields = {
  __typename?: "payment_providers_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type PaymentProvidersStddevPopFields = {
  __typename?: "payment_providers_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type PaymentProvidersStddevSampFields = {
  __typename?: "payment_providers_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "payment_providers" */
export type PaymentProvidersStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: PaymentProvidersStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type PaymentProvidersStreamCursorValueInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate sum on columns */
export type PaymentProvidersSumFields = {
  __typename?: "payment_providers_sum_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "payment_providers" */
export enum PaymentProvidersUpdateColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  IS_ACTIVE = "is_active",
  /** column name */
  NAME = "name",
  /** column name */
  UPDATED_AT = "updated_at",
}

export type PaymentProvidersUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<PaymentProvidersIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<PaymentProvidersSetInput>;
  /** filter the rows which have to be updated */
  where: PaymentProvidersBoolExp;
};

/** aggregate var_pop on columns */
export type PaymentProvidersVarPopFields = {
  __typename?: "payment_providers_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type PaymentProvidersVarSampFields = {
  __typename?: "payment_providers_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type PaymentProvidersVarianceFields = {
  __typename?: "payment_providers_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "plan_permissions" */
export type PlanPermissions = {
  __typename?: "plan_permissions";
  feature: Scalars["String"]["output"];
  id: Scalars["Int"]["output"];
  plan: Scalars["app_plan_enum"]["output"];
};

/** aggregated selection of "plan_permissions" */
export type PlanPermissionsAggregate = {
  __typename?: "plan_permissions_aggregate";
  aggregate?: Maybe<PlanPermissionsAggregateFields>;
  nodes: Array<PlanPermissions>;
};

/** aggregate fields of "plan_permissions" */
export type PlanPermissionsAggregateFields = {
  __typename?: "plan_permissions_aggregate_fields";
  avg?: Maybe<PlanPermissionsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<PlanPermissionsMaxFields>;
  min?: Maybe<PlanPermissionsMinFields>;
  stddev?: Maybe<PlanPermissionsStddevFields>;
  stddev_pop?: Maybe<PlanPermissionsStddevPopFields>;
  stddev_samp?: Maybe<PlanPermissionsStddevSampFields>;
  sum?: Maybe<PlanPermissionsSumFields>;
  var_pop?: Maybe<PlanPermissionsVarPopFields>;
  var_samp?: Maybe<PlanPermissionsVarSampFields>;
  variance?: Maybe<PlanPermissionsVarianceFields>;
};

/** aggregate fields of "plan_permissions" */
export type PlanPermissionsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<PlanPermissionsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type PlanPermissionsAvgFields = {
  __typename?: "plan_permissions_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "plan_permissions". All fields are combined with a logical 'AND'. */
export type PlanPermissionsBoolExp = {
  _and?: InputMaybe<Array<PlanPermissionsBoolExp>>;
  _not?: InputMaybe<PlanPermissionsBoolExp>;
  _or?: InputMaybe<Array<PlanPermissionsBoolExp>>;
  feature?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  plan?: InputMaybe<AppPlanEnumComparisonExp>;
};

/** unique or primary key constraints on table "plan_permissions" */
export enum PlanPermissionsConstraint {
  /** unique or primary key constraint on columns "id" */
  PLAN_PERMISSIONS_PKEY = "plan_permissions_pkey",
}

/** input type for incrementing numeric columns in table "plan_permissions" */
export type PlanPermissionsIncInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "plan_permissions" */
export type PlanPermissionsInsertInput = {
  feature?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  plan?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
};

/** aggregate max on columns */
export type PlanPermissionsMaxFields = {
  __typename?: "plan_permissions_max_fields";
  feature?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  plan?: Maybe<Scalars["app_plan_enum"]["output"]>;
};

/** aggregate min on columns */
export type PlanPermissionsMinFields = {
  __typename?: "plan_permissions_min_fields";
  feature?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  plan?: Maybe<Scalars["app_plan_enum"]["output"]>;
};

/** response of any mutation on the table "plan_permissions" */
export type PlanPermissionsMutationResponse = {
  __typename?: "plan_permissions_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<PlanPermissions>;
};

/** on_conflict condition type for table "plan_permissions" */
export type PlanPermissionsOnConflict = {
  constraint: PlanPermissionsConstraint;
  update_columns?: Array<PlanPermissionsUpdateColumn>;
  where?: InputMaybe<PlanPermissionsBoolExp>;
};

/** Ordering options when selecting data from "plan_permissions". */
export type PlanPermissionsOrderBy = {
  feature?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  plan?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: plan_permissions */
export type PlanPermissionsPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "plan_permissions" */
export enum PlanPermissionsSelectColumn {
  /** column name */
  FEATURE = "feature",
  /** column name */
  ID = "id",
  /** column name */
  PLAN = "plan",
}

/** input type for updating data in table "plan_permissions" */
export type PlanPermissionsSetInput = {
  feature?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  plan?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
};

/** aggregate stddev on columns */
export type PlanPermissionsStddevFields = {
  __typename?: "plan_permissions_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type PlanPermissionsStddevPopFields = {
  __typename?: "plan_permissions_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type PlanPermissionsStddevSampFields = {
  __typename?: "plan_permissions_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "plan_permissions" */
export type PlanPermissionsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: PlanPermissionsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type PlanPermissionsStreamCursorValueInput = {
  feature?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  plan?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
};

/** aggregate sum on columns */
export type PlanPermissionsSumFields = {
  __typename?: "plan_permissions_sum_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "plan_permissions" */
export enum PlanPermissionsUpdateColumn {
  /** column name */
  FEATURE = "feature",
  /** column name */
  ID = "id",
  /** column name */
  PLAN = "plan",
}

export type PlanPermissionsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<PlanPermissionsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<PlanPermissionsSetInput>;
  /** filter the rows which have to be updated */
  where: PlanPermissionsBoolExp;
};

/** aggregate var_pop on columns */
export type PlanPermissionsVarPopFields = {
  __typename?: "plan_permissions_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type PlanPermissionsVarSampFields = {
  __typename?: "plan_permissions_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type PlanPermissionsVarianceFields = {
  __typename?: "plan_permissions_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to compare columns of type "priority". All fields are combined with logical 'AND'. */
export type PriorityComparisonExp = {
  _eq?: InputMaybe<Scalars["priority"]["input"]>;
  _gt?: InputMaybe<Scalars["priority"]["input"]>;
  _gte?: InputMaybe<Scalars["priority"]["input"]>;
  _in?: InputMaybe<Array<Scalars["priority"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["priority"]["input"]>;
  _lte?: InputMaybe<Scalars["priority"]["input"]>;
  _neq?: InputMaybe<Scalars["priority"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["priority"]["input"]>>;
};

/** Boolean expression to compare columns of type "privacy_level". All fields are combined with logical 'AND'. */
export type PrivacyLevelComparisonExp = {
  _eq?: InputMaybe<Scalars["privacy_level"]["input"]>;
  _gt?: InputMaybe<Scalars["privacy_level"]["input"]>;
  _gte?: InputMaybe<Scalars["privacy_level"]["input"]>;
  _in?: InputMaybe<Array<Scalars["privacy_level"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["privacy_level"]["input"]>;
  _lte?: InputMaybe<Scalars["privacy_level"]["input"]>;
  _neq?: InputMaybe<Scalars["privacy_level"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["privacy_level"]["input"]>>;
};

export type QueryRoot = {
  __typename?: "query_root";
  /** An array relationship */
  ad_daily_metrics: Array<AdDailyMetrics>;
  /** An aggregate relationship */
  ad_daily_metrics_aggregate: AdDailyMetricsAggregate;
  /** fetch data from the table: "ad_daily_metrics" using primary key columns */
  ad_daily_metrics_by_pk?: Maybe<AdDailyMetrics>;
  /** fetch data from the table: "ad_packages" */
  ad_packages: Array<AdPackages>;
  /** fetch aggregated fields from the table: "ad_packages" */
  ad_packages_aggregate: AdPackagesAggregate;
  /** fetch data from the table: "ad_packages" using primary key columns */
  ad_packages_by_pk?: Maybe<AdPackages>;
  /** An array relationship */
  ad_variants: Array<AdVariants>;
  /** An aggregate relationship */
  ad_variants_aggregate: AdVariantsAggregate;
  /** fetch data from the table: "ad_variants" using primary key columns */
  ad_variants_by_pk?: Maybe<AdVariants>;
  /** An array relationship */
  addresses: Array<Addresses>;
  /** An aggregate relationship */
  addresses_aggregate: AddressesAggregate;
  /** fetch data from the table: "addresses" using primary key columns */
  addresses_by_pk?: Maybe<Addresses>;
  /** An array relationship */
  ads: Array<Ads>;
  /** An aggregate relationship */
  ads_aggregate: AdsAggregate;
  /** fetch data from the table: "ads" using primary key columns */
  ads_by_pk?: Maybe<Ads>;
  /** fetch data from the table: "blacklisted_domains" */
  blacklisted_domains: Array<BlacklistedDomains>;
  /** fetch aggregated fields from the table: "blacklisted_domains" */
  blacklisted_domains_aggregate: BlacklistedDomainsAggregate;
  /** fetch data from the table: "blacklisted_domains" using primary key columns */
  blacklisted_domains_by_pk?: Maybe<BlacklistedDomains>;
  /** An array relationship */
  blacklisted_urls: Array<BlacklistedUrls>;
  /** An aggregate relationship */
  blacklisted_urls_aggregate: BlacklistedUrlsAggregate;
  /** fetch data from the table: "blacklisted_urls" using primary key columns */
  blacklisted_urls_by_pk?: Maybe<BlacklistedUrls>;
  /** fetch data from the table: "blocked_ips" */
  blocked_ips: Array<BlockedIps>;
  /** fetch aggregated fields from the table: "blocked_ips" */
  blocked_ips_aggregate: BlockedIpsAggregate;
  /** fetch data from the table: "blocked_ips" using primary key columns */
  blocked_ips_by_pk?: Maybe<BlockedIps>;
  /** An array relationship */
  bookmark_folders: Array<BookmarkFolders>;
  /** An aggregate relationship */
  bookmark_folders_aggregate: BookmarkFoldersAggregate;
  /** fetch data from the table: "bookmark_folders" using primary key columns */
  bookmark_folders_by_pk?: Maybe<BookmarkFolders>;
  /** An array relationship */
  bookmarks: Array<Bookmarks>;
  /** An aggregate relationship */
  bookmarks_aggregate: BookmarksAggregate;
  /** fetch data from the table: "bookmarks" using primary key columns */
  bookmarks_by_pk?: Maybe<Bookmarks>;
  /** An array relationship */
  business_domains: Array<BusinessDomains>;
  /** An aggregate relationship */
  business_domains_aggregate: BusinessDomainsAggregate;
  /** fetch data from the table: "business_domains" using primary key columns */
  business_domains_by_pk?: Maybe<BusinessDomains>;
  /** fetch data from the table: "categories" */
  categories: Array<Categories>;
  /** fetch aggregated fields from the table: "categories" */
  categories_aggregate: CategoriesAggregate;
  /** fetch data from the table: "categories" using primary key columns */
  categories_by_pk?: Maybe<Categories>;
  /** An array relationship */
  categorized_urls: Array<CategorizedUrls>;
  /** An aggregate relationship */
  categorized_urls_aggregate: CategorizedUrlsAggregate;
  /** fetch data from the table: "categorized_urls" using primary key columns */
  categorized_urls_by_pk?: Maybe<CategorizedUrls>;
  /** fetch data from the table: "circuit_breaker_states" */
  circuit_breaker_states: Array<CircuitBreakerStates>;
  /** fetch aggregated fields from the table: "circuit_breaker_states" */
  circuit_breaker_states_aggregate: CircuitBreakerStatesAggregate;
  /** fetch data from the table: "circuit_breaker_states" using primary key columns */
  circuit_breaker_states_by_pk?: Maybe<CircuitBreakerStates>;
  /** An array relationship */
  cities: Array<Cities>;
  /** An aggregate relationship */
  cities_aggregate: CitiesAggregate;
  /** fetch data from the table: "cities" using primary key columns */
  cities_by_pk?: Maybe<Cities>;
  /** An array relationship */
  comments: Array<Comments>;
  /** An aggregate relationship */
  comments_aggregate: CommentsAggregate;
  /** fetch data from the table: "comments" using primary key columns */
  comments_by_pk?: Maybe<Comments>;
  /** An array relationship */
  companies: Array<Companies>;
  /** An aggregate relationship */
  companies_aggregate: CompaniesAggregate;
  /** fetch data from the table: "companies" using primary key columns */
  companies_by_pk?: Maybe<Companies>;
  /** An array relationship */
  company_contacts: Array<CompanyContacts>;
  /** An aggregate relationship */
  company_contacts_aggregate: CompanyContactsAggregate;
  /** fetch data from the table: "company_contacts" using primary key columns */
  company_contacts_by_pk?: Maybe<CompanyContacts>;
  /** An array relationship */
  company_employees: Array<CompanyEmployees>;
  /** An aggregate relationship */
  company_employees_aggregate: CompanyEmployeesAggregate;
  /** fetch data from the table: "company_employees" using primary key columns */
  company_employees_by_pk?: Maybe<CompanyEmployees>;
  /** An array relationship */
  company_extras: Array<CompanyExtras>;
  /** An aggregate relationship */
  company_extras_aggregate: CompanyExtrasAggregate;
  /** fetch data from the table: "company_extras" using primary key columns */
  company_extras_by_pk?: Maybe<CompanyExtras>;
  /** An array relationship */
  company_metrics: Array<CompanyMetrics>;
  /** An aggregate relationship */
  company_metrics_aggregate: CompanyMetricsAggregate;
  /** fetch data from the table: "company_metrics" using primary key columns */
  company_metrics_by_pk?: Maybe<CompanyMetrics>;
  /** An array relationship */
  contacts: Array<Contacts>;
  /** An aggregate relationship */
  contacts_aggregate: ContactsAggregate;
  /** fetch data from the table: "contacts" using primary key columns */
  contacts_by_pk?: Maybe<Contacts>;
  /** An array relationship */
  content_categories: Array<ContentCategories>;
  /** An aggregate relationship */
  content_categories_aggregate: ContentCategoriesAggregate;
  /** fetch data from the table: "content_categories" using primary key columns */
  content_categories_by_pk?: Maybe<ContentCategories>;
  /** fetch data from the table: "content_scores" */
  content_scores: Array<ContentScores>;
  /** fetch aggregated fields from the table: "content_scores" */
  content_scores_aggregate: ContentScoresAggregate;
  /** An array relationship */
  content_source_visits: Array<ContentSourceVisits>;
  /** An aggregate relationship */
  content_source_visits_aggregate: ContentSourceVisitsAggregate;
  /** fetch data from the table: "content_source_visits" using primary key columns */
  content_source_visits_by_pk?: Maybe<ContentSourceVisits>;
  /** An array relationship */
  content_sources: Array<ContentSources>;
  /** An aggregate relationship */
  content_sources_aggregate: ContentSourcesAggregate;
  /** fetch data from the table: "content_sources" using primary key columns */
  content_sources_by_pk?: Maybe<ContentSources>;
  /** An array relationship */
  content_statuses: Array<ContentStatuses>;
  /** An aggregate relationship */
  content_statuses_aggregate: ContentStatusesAggregate;
  /** fetch data from the table: "content_statuses" using primary key columns */
  content_statuses_by_pk?: Maybe<ContentStatuses>;
  /** An array relationship */
  content_tags: Array<ContentTags>;
  /** An aggregate relationship */
  content_tags_aggregate: ContentTagsAggregate;
  /** fetch data from the table: "content_tags" using primary key columns */
  content_tags_by_pk?: Maybe<ContentTags>;
  /** fetch data from the table: "contents" */
  contents: Array<Contents>;
  /** fetch aggregated fields from the table: "contents" */
  contents_aggregate: ContentsAggregate;
  /** fetch data from the table: "contents" using primary key columns */
  contents_by_pk?: Maybe<Contents>;
  /** fetch data from the table: "countries" */
  countries: Array<Countries>;
  /** fetch aggregated fields from the table: "countries" */
  countries_aggregate: CountriesAggregate;
  /** fetch data from the table: "countries" using primary key columns */
  countries_by_pk?: Maybe<Countries>;
  /** An array relationship */
  customer_payments: Array<CustomerPayments>;
  /** An aggregate relationship */
  customer_payments_aggregate: CustomerPaymentsAggregate;
  /** fetch data from the table: "customer_payments" using primary key columns */
  customer_payments_by_pk?: Maybe<CustomerPayments>;
  /** fetch data from the table: "customer_processed_webhooks" */
  customer_processed_webhooks: Array<CustomerProcessedWebhooks>;
  /** fetch aggregated fields from the table: "customer_processed_webhooks" */
  customer_processed_webhooks_aggregate: CustomerProcessedWebhooksAggregate;
  /** fetch data from the table: "customer_processed_webhooks" using primary key columns */
  customer_processed_webhooks_by_pk?: Maybe<CustomerProcessedWebhooks>;
  /** An array relationship */
  customer_refunds: Array<CustomerRefunds>;
  /** An aggregate relationship */
  customer_refunds_aggregate: CustomerRefundsAggregate;
  /** fetch data from the table: "customer_refunds" using primary key columns */
  customer_refunds_by_pk?: Maybe<CustomerRefunds>;
  /** fetch data from the table: "customer_subscription_plans" */
  customer_subscription_plans: Array<CustomerSubscriptionPlans>;
  /** fetch aggregated fields from the table: "customer_subscription_plans" */
  customer_subscription_plans_aggregate: CustomerSubscriptionPlansAggregate;
  /** fetch data from the table: "customer_subscription_plans" using primary key columns */
  customer_subscription_plans_by_pk?: Maybe<CustomerSubscriptionPlans>;
  /** An array relationship */
  customer_subscriptions: Array<CustomerSubscriptions>;
  /** An aggregate relationship */
  customer_subscriptions_aggregate: CustomerSubscriptionsAggregate;
  /** fetch data from the table: "customer_subscriptions" using primary key columns */
  customer_subscriptions_by_pk?: Maybe<CustomerSubscriptions>;
  /** fetch data from the table: "embedding_reviews" */
  embedding_reviews: Array<EmbeddingReviews>;
  /** fetch aggregated fields from the table: "embedding_reviews" */
  embedding_reviews_aggregate: EmbeddingReviewsAggregate;
  /** fetch data from the table: "embedding_reviews" using primary key columns */
  embedding_reviews_by_pk?: Maybe<EmbeddingReviews>;
  /** fetch data from the table: "error_correlations" */
  error_correlations: Array<ErrorCorrelations>;
  /** fetch aggregated fields from the table: "error_correlations" */
  error_correlations_aggregate: ErrorCorrelationsAggregate;
  /** fetch data from the table: "error_frequency" */
  error_frequency: Array<ErrorFrequency>;
  /** fetch aggregated fields from the table: "error_frequency" */
  error_frequency_aggregate: ErrorFrequencyAggregate;
  /** fetch data from the table: "error_logs" */
  error_logs: Array<ErrorLogs>;
  /** fetch aggregated fields from the table: "error_logs" */
  error_logs_aggregate: ErrorLogsAggregate;
  /** fetch data from the table: "error_logs" using primary key columns */
  error_logs_by_pk?: Maybe<ErrorLogs>;
  /** fetch data from the table: "error_metrics" */
  error_metrics: Array<ErrorMetrics>;
  /** fetch aggregated fields from the table: "error_metrics" */
  error_metrics_aggregate: ErrorMetricsAggregate;
  /** fetch data from the table: "error_patterns" */
  error_patterns: Array<ErrorPatterns>;
  /** fetch aggregated fields from the table: "error_patterns" */
  error_patterns_aggregate: ErrorPatternsAggregate;
  /** fetch data from the table: "error_stats" */
  error_stats: Array<ErrorStats>;
  /** fetch aggregated fields from the table: "error_stats" */
  error_stats_aggregate: ErrorStatsAggregate;
  /** fetch data from the table: "feature_requests" */
  feature_requests: Array<FeatureRequests>;
  /** fetch aggregated fields from the table: "feature_requests" */
  feature_requests_aggregate: FeatureRequestsAggregate;
  /** fetch data from the table: "feature_requests" using primary key columns */
  feature_requests_by_pk?: Maybe<FeatureRequests>;
  /** An array relationship */
  feature_votes: Array<FeatureVotes>;
  /** An aggregate relationship */
  feature_votes_aggregate: FeatureVotesAggregate;
  /** fetch data from the table: "feature_votes" using primary key columns */
  feature_votes_by_pk?: Maybe<FeatureVotes>;
  /** An array relationship */
  feed_categories: Array<FeedCategories>;
  /** An aggregate relationship */
  feed_categories_aggregate: FeedCategoriesAggregate;
  /** fetch data from the table: "feed_categories" using primary key columns */
  feed_categories_by_pk?: Maybe<FeedCategories>;
  /** An array relationship */
  feed_sources: Array<FeedSources>;
  /** An aggregate relationship */
  feed_sources_aggregate: FeedSourcesAggregate;
  /** fetch data from the table: "feed_sources" using primary key columns */
  feed_sources_by_pk?: Maybe<FeedSources>;
  /** An array relationship */
  feedbacks: Array<Feedbacks>;
  /** An aggregate relationship */
  feedbacks_aggregate: FeedbacksAggregate;
  /** fetch data from the table: "feedbacks" using primary key columns */
  feedbacks_by_pk?: Maybe<Feedbacks>;
  /** An array relationship */
  feeds: Array<Feeds>;
  /** An aggregate relationship */
  feeds_aggregate: FeedsAggregate;
  /** fetch data from the table: "feeds" using primary key columns */
  feeds_by_pk?: Maybe<Feeds>;
  /** An array relationship */
  follows: Array<Follows>;
  /** An aggregate relationship */
  follows_aggregate: FollowsAggregate;
  /** fetch data from the table: "follows" using primary key columns */
  follows_by_pk?: Maybe<Follows>;
  /** fetch data from the table: "metric_definitions" */
  metric_definitions: Array<MetricDefinitions>;
  /** fetch aggregated fields from the table: "metric_definitions" */
  metric_definitions_aggregate: MetricDefinitionsAggregate;
  /** fetch data from the table: "metric_definitions" using primary key columns */
  metric_definitions_by_pk?: Maybe<MetricDefinitions>;
  /** An array relationship */
  news: Array<News>;
  /** An aggregate relationship */
  news_aggregate: NewsAggregate;
  /** fetch data from the table: "news" using primary key columns */
  news_by_pk?: Maybe<News>;
  /** fetch data from the table: "news_details" */
  news_details: Array<NewsDetails>;
  /** fetch aggregated fields from the table: "news_details" */
  news_details_aggregate: NewsDetailsAggregate;
  /** An array relationship */
  news_summaries: Array<NewsSummaries>;
  /** An aggregate relationship */
  news_summaries_aggregate: NewsSummariesAggregate;
  /** fetch data from the table: "news_summaries" using primary key columns */
  news_summaries_by_pk?: Maybe<NewsSummaries>;
  /** An array relationship */
  news_tags: Array<NewsTags>;
  /** An aggregate relationship */
  news_tags_aggregate: NewsTagsAggregate;
  /** fetch data from the table: "news_tags" using primary key columns */
  news_tags_by_pk?: Maybe<NewsTags>;
  /** fetch data from the table: "newsletters" */
  newsletters: Array<Newsletters>;
  /** fetch aggregated fields from the table: "newsletters" */
  newsletters_aggregate: NewslettersAggregate;
  /** fetch data from the table: "newsletters" using primary key columns */
  newsletters_by_pk?: Maybe<Newsletters>;
  /** fetch data from the table: "payment_providers" */
  payment_providers: Array<PaymentProviders>;
  /** fetch aggregated fields from the table: "payment_providers" */
  payment_providers_aggregate: PaymentProvidersAggregate;
  /** fetch data from the table: "payment_providers" using primary key columns */
  payment_providers_by_pk?: Maybe<PaymentProviders>;
  /** fetch data from the table: "plan_permissions" */
  plan_permissions: Array<PlanPermissions>;
  /** fetch aggregated fields from the table: "plan_permissions" */
  plan_permissions_aggregate: PlanPermissionsAggregate;
  /** fetch data from the table: "plan_permissions" using primary key columns */
  plan_permissions_by_pk?: Maybe<PlanPermissions>;
  /** fetch data from the table: "recent_errors" */
  recent_errors: Array<RecentErrors>;
  /** fetch aggregated fields from the table: "recent_errors" */
  recent_errors_aggregate: RecentErrorsAggregate;
  /** fetch data from the table: "referral_stats" */
  referral_stats: Array<ReferralStats>;
  /** fetch aggregated fields from the table: "referral_stats" */
  referral_stats_aggregate: ReferralStatsAggregate;
  /** fetch data from the table: "referrals" */
  referrals: Array<Referrals>;
  /** fetch aggregated fields from the table: "referrals" */
  referrals_aggregate: ReferralsAggregate;
  /** fetch data from the table: "referrals" using primary key columns */
  referrals_by_pk?: Maybe<Referrals>;
  /** fetch data from the table: "referrer_blocks" */
  referrer_blocks: Array<ReferrerBlocks>;
  /** fetch aggregated fields from the table: "referrer_blocks" */
  referrer_blocks_aggregate: ReferrerBlocksAggregate;
  /** fetch data from the table: "referrer_blocks" using primary key columns */
  referrer_blocks_by_pk?: Maybe<ReferrerBlocks>;
  /** fetch data from the table: "referrer_risk_metrics" */
  referrer_risk_metrics: Array<ReferrerRiskMetrics>;
  /** fetch aggregated fields from the table: "referrer_risk_metrics" */
  referrer_risk_metrics_aggregate: ReferrerRiskMetricsAggregate;
  /** fetch data from the table: "research" */
  research: Array<Research>;
  /** fetch aggregated fields from the table: "research" */
  research_aggregate: ResearchAggregate;
  /** fetch data from the table: "research" using primary key columns */
  research_by_pk?: Maybe<Research>;
  /** An array relationship */
  research_embeddings: Array<ResearchEmbeddings>;
  /** An aggregate relationship */
  research_embeddings_aggregate: ResearchEmbeddingsAggregate;
  /** fetch data from the table: "research_embeddings" using primary key columns */
  research_embeddings_by_pk?: Maybe<ResearchEmbeddings>;
  /** An array relationship */
  responses: Array<Responses>;
  /** An aggregate relationship */
  responses_aggregate: ResponsesAggregate;
  /** fetch data from the table: "responses" using primary key columns */
  responses_by_pk?: Maybe<Responses>;
  /** fetch data from the table: "role_hierarchy" */
  role_hierarchy: Array<RoleHierarchy>;
  /** fetch aggregated fields from the table: "role_hierarchy" */
  role_hierarchy_aggregate: RoleHierarchyAggregate;
  /** fetch data from the table: "role_hierarchy" using primary key columns */
  role_hierarchy_by_pk?: Maybe<RoleHierarchy>;
  /** fetch data from the table: "role_permissions" */
  role_permissions: Array<RolePermissions>;
  /** fetch aggregated fields from the table: "role_permissions" */
  role_permissions_aggregate: RolePermissionsAggregate;
  /** fetch data from the table: "role_permissions" using primary key columns */
  role_permissions_by_pk?: Maybe<RolePermissions>;
  /** fetch data from the table: "role_permissions_materialized" */
  role_permissions_materialized: Array<RolePermissionsMaterialized>;
  /** fetch aggregated fields from the table: "role_permissions_materialized" */
  role_permissions_materialized_aggregate: RolePermissionsMaterializedAggregate;
  /** fetch data from the table: "role_permissions_materialized" using primary key columns */
  role_permissions_materialized_by_pk?: Maybe<RolePermissionsMaterialized>;
  /** fetch data from the table: "scoring_weights" */
  scoring_weights: Array<ScoringWeights>;
  /** fetch aggregated fields from the table: "scoring_weights" */
  scoring_weights_aggregate: ScoringWeightsAggregate;
  /** fetch data from the table: "scoring_weights" using primary key columns */
  scoring_weights_by_pk?: Maybe<ScoringWeights>;
  /** fetch data from the table: "searches" */
  searches: Array<Searches>;
  /** fetch aggregated fields from the table: "searches" */
  searches_aggregate: SearchesAggregate;
  /** fetch data from the table: "searches" using primary key columns */
  searches_by_pk?: Maybe<Searches>;
  /** fetch data from the table: "security_metrics" */
  security_metrics: Array<SecurityMetrics>;
  /** fetch aggregated fields from the table: "security_metrics" */
  security_metrics_aggregate: SecurityMetricsAggregate;
  /** fetch data from the table: "slow_query_patterns" */
  slow_query_patterns: Array<SlowQueryPatterns>;
  /** fetch aggregated fields from the table: "slow_query_patterns" */
  slow_query_patterns_aggregate: SlowQueryPatternsAggregate;
  /** fetch data from the table: "social_media" */
  social_media: Array<SocialMedia>;
  /** fetch aggregated fields from the table: "social_media" */
  social_media_aggregate: SocialMediaAggregate;
  /** fetch data from the table: "social_media" using primary key columns */
  social_media_by_pk?: Maybe<SocialMedia>;
  /** An array relationship */
  spider_metrics: Array<SpiderMetrics>;
  /** An aggregate relationship */
  spider_metrics_aggregate: SpiderMetricsAggregate;
  /** fetch data from the table: "spider_metrics" using primary key columns */
  spider_metrics_by_pk?: Maybe<SpiderMetrics>;
  /** fetch data from the table: "strapi_migrations" */
  strapi_migrations: Array<StrapiMigrations>;
  /** fetch aggregated fields from the table: "strapi_migrations" */
  strapi_migrations_aggregate: StrapiMigrationsAggregate;
  /** fetch data from the table: "strapi_migrations" using primary key columns */
  strapi_migrations_by_pk?: Maybe<StrapiMigrations>;
  /** fetch data from the table: "strapi_migrations_internal" */
  strapi_migrations_internal: Array<StrapiMigrationsInternal>;
  /** fetch aggregated fields from the table: "strapi_migrations_internal" */
  strapi_migrations_internal_aggregate: StrapiMigrationsInternalAggregate;
  /** fetch data from the table: "strapi_migrations_internal" using primary key columns */
  strapi_migrations_internal_by_pk?: Maybe<StrapiMigrationsInternal>;
  /** fetch data from the table: "table_maintenance_log" */
  table_maintenance_log: Array<TableMaintenanceLog>;
  /** fetch aggregated fields from the table: "table_maintenance_log" */
  table_maintenance_log_aggregate: TableMaintenanceLogAggregate;
  /** fetch data from the table: "table_maintenance_log" using primary key columns */
  table_maintenance_log_by_pk?: Maybe<TableMaintenanceLog>;
  /** fetch data from the table: "table_query_performance" */
  table_query_performance: Array<TableQueryPerformance>;
  /** fetch aggregated fields from the table: "table_query_performance" */
  table_query_performance_aggregate: TableQueryPerformanceAggregate;
  /** fetch data from the table: "table_sequence_usage" */
  table_sequence_usage: Array<TableSequenceUsage>;
  /** fetch aggregated fields from the table: "table_sequence_usage" */
  table_sequence_usage_aggregate: TableSequenceUsageAggregate;
  /** fetch data from the table: "table_statistics" */
  table_statistics: Array<TableStatistics>;
  /** fetch aggregated fields from the table: "table_statistics" */
  table_statistics_aggregate: TableStatisticsAggregate;
  /** fetch data from the table: "table_statistics" using primary key columns */
  table_statistics_by_pk?: Maybe<TableStatistics>;
  /** fetch data from the table: "tags" */
  tags: Array<Tags>;
  /** fetch aggregated fields from the table: "tags" */
  tags_aggregate: TagsAggregate;
  /** fetch data from the table: "tags" using primary key columns */
  tags_by_pk?: Maybe<Tags>;
  /** fetch data from the table: "user_metrics" */
  user_metrics: Array<UserMetrics>;
  /** fetch aggregated fields from the table: "user_metrics" */
  user_metrics_aggregate: UserMetricsAggregate;
  /** fetch data from the table: "user_metrics" using primary key columns */
  user_metrics_by_pk?: Maybe<UserMetrics>;
  /** fetch data from the table: "user_profiles" */
  user_profiles: Array<UserProfiles>;
  /** fetch aggregated fields from the table: "user_profiles" */
  user_profiles_aggregate: UserProfilesAggregate;
  /** fetch data from the table: "user_profiles" using primary key columns */
  user_profiles_by_pk?: Maybe<UserProfiles>;
  /** fetch data from the table: "votes" */
  votes: Array<Votes>;
  /** fetch aggregated fields from the table: "votes" */
  votes_aggregate: VotesAggregate;
  /** fetch data from the table: "votes" using primary key columns */
  votes_by_pk?: Maybe<Votes>;
  /** fetch data from the table: "workflows" */
  workflows: Array<Workflows>;
  /** fetch aggregated fields from the table: "workflows" */
  workflows_aggregate: WorkflowsAggregate;
  /** fetch data from the table: "workflows" using primary key columns */
  workflows_by_pk?: Maybe<Workflows>;
};

export type QueryRootAdDailyMetricsArgs = {
  distinct_on?: InputMaybe<Array<AdDailyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdDailyMetricsOrderBy>>;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
};

export type QueryRootAdDailyMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<AdDailyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdDailyMetricsOrderBy>>;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
};

export type QueryRootAdDailyMetricsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootAdPackagesArgs = {
  distinct_on?: InputMaybe<Array<AdPackagesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdPackagesOrderBy>>;
  where?: InputMaybe<AdPackagesBoolExp>;
};

export type QueryRootAdPackagesAggregateArgs = {
  distinct_on?: InputMaybe<Array<AdPackagesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdPackagesOrderBy>>;
  where?: InputMaybe<AdPackagesBoolExp>;
};

export type QueryRootAdPackagesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootAdVariantsArgs = {
  distinct_on?: InputMaybe<Array<AdVariantsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdVariantsOrderBy>>;
  where?: InputMaybe<AdVariantsBoolExp>;
};

export type QueryRootAdVariantsAggregateArgs = {
  distinct_on?: InputMaybe<Array<AdVariantsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdVariantsOrderBy>>;
  where?: InputMaybe<AdVariantsBoolExp>;
};

export type QueryRootAdVariantsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootAddressesArgs = {
  distinct_on?: InputMaybe<Array<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

export type QueryRootAddressesAggregateArgs = {
  distinct_on?: InputMaybe<Array<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

export type QueryRootAddressesByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootAdsArgs = {
  distinct_on?: InputMaybe<Array<AdsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdsOrderBy>>;
  where?: InputMaybe<AdsBoolExp>;
};

export type QueryRootAdsAggregateArgs = {
  distinct_on?: InputMaybe<Array<AdsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdsOrderBy>>;
  where?: InputMaybe<AdsBoolExp>;
};

export type QueryRootAdsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootBlacklistedDomainsArgs = {
  distinct_on?: InputMaybe<Array<BlacklistedDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlacklistedDomainsOrderBy>>;
  where?: InputMaybe<BlacklistedDomainsBoolExp>;
};

export type QueryRootBlacklistedDomainsAggregateArgs = {
  distinct_on?: InputMaybe<Array<BlacklistedDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlacklistedDomainsOrderBy>>;
  where?: InputMaybe<BlacklistedDomainsBoolExp>;
};

export type QueryRootBlacklistedDomainsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootBlacklistedUrlsArgs = {
  distinct_on?: InputMaybe<Array<BlacklistedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlacklistedUrlsOrderBy>>;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
};

export type QueryRootBlacklistedUrlsAggregateArgs = {
  distinct_on?: InputMaybe<Array<BlacklistedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlacklistedUrlsOrderBy>>;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
};

export type QueryRootBlacklistedUrlsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootBlockedIpsArgs = {
  distinct_on?: InputMaybe<Array<BlockedIpsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlockedIpsOrderBy>>;
  where?: InputMaybe<BlockedIpsBoolExp>;
};

export type QueryRootBlockedIpsAggregateArgs = {
  distinct_on?: InputMaybe<Array<BlockedIpsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlockedIpsOrderBy>>;
  where?: InputMaybe<BlockedIpsBoolExp>;
};

export type QueryRootBlockedIpsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootBookmarkFoldersArgs = {
  distinct_on?: InputMaybe<Array<BookmarkFoldersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarkFoldersOrderBy>>;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
};

export type QueryRootBookmarkFoldersAggregateArgs = {
  distinct_on?: InputMaybe<Array<BookmarkFoldersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarkFoldersOrderBy>>;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
};

export type QueryRootBookmarkFoldersByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootBookmarksArgs = {
  distinct_on?: InputMaybe<Array<BookmarksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarksOrderBy>>;
  where?: InputMaybe<BookmarksBoolExp>;
};

export type QueryRootBookmarksAggregateArgs = {
  distinct_on?: InputMaybe<Array<BookmarksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarksOrderBy>>;
  where?: InputMaybe<BookmarksBoolExp>;
};

export type QueryRootBookmarksByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootBusinessDomainsArgs = {
  distinct_on?: InputMaybe<Array<BusinessDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BusinessDomainsOrderBy>>;
  where?: InputMaybe<BusinessDomainsBoolExp>;
};

export type QueryRootBusinessDomainsAggregateArgs = {
  distinct_on?: InputMaybe<Array<BusinessDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BusinessDomainsOrderBy>>;
  where?: InputMaybe<BusinessDomainsBoolExp>;
};

export type QueryRootBusinessDomainsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootCategoriesArgs = {
  distinct_on?: InputMaybe<Array<CategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategoriesOrderBy>>;
  where?: InputMaybe<CategoriesBoolExp>;
};

export type QueryRootCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategoriesOrderBy>>;
  where?: InputMaybe<CategoriesBoolExp>;
};

export type QueryRootCategoriesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootCategorizedUrlsArgs = {
  distinct_on?: InputMaybe<Array<CategorizedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategorizedUrlsOrderBy>>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
};

export type QueryRootCategorizedUrlsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CategorizedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategorizedUrlsOrderBy>>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
};

export type QueryRootCategorizedUrlsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootCircuitBreakerStatesArgs = {
  distinct_on?: InputMaybe<Array<CircuitBreakerStatesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CircuitBreakerStatesOrderBy>>;
  where?: InputMaybe<CircuitBreakerStatesBoolExp>;
};

export type QueryRootCircuitBreakerStatesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CircuitBreakerStatesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CircuitBreakerStatesOrderBy>>;
  where?: InputMaybe<CircuitBreakerStatesBoolExp>;
};

export type QueryRootCircuitBreakerStatesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootCitiesArgs = {
  distinct_on?: InputMaybe<Array<CitiesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CitiesOrderBy>>;
  where?: InputMaybe<CitiesBoolExp>;
};

export type QueryRootCitiesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CitiesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CitiesOrderBy>>;
  where?: InputMaybe<CitiesBoolExp>;
};

export type QueryRootCitiesByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCommentsArgs = {
  distinct_on?: InputMaybe<Array<CommentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CommentsOrderBy>>;
  where?: InputMaybe<CommentsBoolExp>;
};

export type QueryRootCommentsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CommentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CommentsOrderBy>>;
  where?: InputMaybe<CommentsBoolExp>;
};

export type QueryRootCommentsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootCompaniesArgs = {
  distinct_on?: InputMaybe<Array<CompaniesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompaniesOrderBy>>;
  where?: InputMaybe<CompaniesBoolExp>;
};

export type QueryRootCompaniesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompaniesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompaniesOrderBy>>;
  where?: InputMaybe<CompaniesBoolExp>;
};

export type QueryRootCompaniesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootCompanyContactsArgs = {
  distinct_on?: InputMaybe<Array<CompanyContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyContactsOrderBy>>;
  where?: InputMaybe<CompanyContactsBoolExp>;
};

export type QueryRootCompanyContactsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompanyContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyContactsOrderBy>>;
  where?: InputMaybe<CompanyContactsBoolExp>;
};

export type QueryRootCompanyContactsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCompanyEmployeesArgs = {
  distinct_on?: InputMaybe<Array<CompanyEmployeesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyEmployeesOrderBy>>;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
};

export type QueryRootCompanyEmployeesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompanyEmployeesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyEmployeesOrderBy>>;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
};

export type QueryRootCompanyEmployeesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootCompanyExtrasArgs = {
  distinct_on?: InputMaybe<Array<CompanyExtrasSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyExtrasOrderBy>>;
  where?: InputMaybe<CompanyExtrasBoolExp>;
};

export type QueryRootCompanyExtrasAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompanyExtrasSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyExtrasOrderBy>>;
  where?: InputMaybe<CompanyExtrasBoolExp>;
};

export type QueryRootCompanyExtrasByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCompanyMetricsArgs = {
  distinct_on?: InputMaybe<Array<CompanyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyMetricsOrderBy>>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
};

export type QueryRootCompanyMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompanyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyMetricsOrderBy>>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
};

export type QueryRootCompanyMetricsByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootContactsArgs = {
  distinct_on?: InputMaybe<Array<ContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContactsOrderBy>>;
  where?: InputMaybe<ContactsBoolExp>;
};

export type QueryRootContactsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContactsOrderBy>>;
  where?: InputMaybe<ContactsBoolExp>;
};

export type QueryRootContactsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootContentCategoriesArgs = {
  distinct_on?: InputMaybe<Array<ContentCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentCategoriesOrderBy>>;
  where?: InputMaybe<ContentCategoriesBoolExp>;
};

export type QueryRootContentCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentCategoriesOrderBy>>;
  where?: InputMaybe<ContentCategoriesBoolExp>;
};

export type QueryRootContentCategoriesByPkArgs = {
  category_id: Scalars["bigint"]["input"];
  content_id: Scalars["uuid"]["input"];
};

export type QueryRootContentScoresArgs = {
  distinct_on?: InputMaybe<Array<ContentScoresSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentScoresOrderBy>>;
  where?: InputMaybe<ContentScoresBoolExp>;
};

export type QueryRootContentScoresAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentScoresSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentScoresOrderBy>>;
  where?: InputMaybe<ContentScoresBoolExp>;
};

export type QueryRootContentSourceVisitsArgs = {
  distinct_on?: InputMaybe<Array<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

export type QueryRootContentSourceVisitsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

export type QueryRootContentSourceVisitsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootContentSourcesArgs = {
  distinct_on?: InputMaybe<Array<ContentSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourcesOrderBy>>;
  where?: InputMaybe<ContentSourcesBoolExp>;
};

export type QueryRootContentSourcesAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourcesOrderBy>>;
  where?: InputMaybe<ContentSourcesBoolExp>;
};

export type QueryRootContentSourcesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootContentStatusesArgs = {
  distinct_on?: InputMaybe<Array<ContentStatusesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentStatusesOrderBy>>;
  where?: InputMaybe<ContentStatusesBoolExp>;
};

export type QueryRootContentStatusesAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentStatusesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentStatusesOrderBy>>;
  where?: InputMaybe<ContentStatusesBoolExp>;
};

export type QueryRootContentStatusesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootContentTagsArgs = {
  distinct_on?: InputMaybe<Array<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentTagsOrderBy>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

export type QueryRootContentTagsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentTagsOrderBy>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

export type QueryRootContentTagsByPkArgs = {
  content_id: Scalars["uuid"]["input"];
  tag_id: Scalars["Int"]["input"];
};

export type QueryRootContentsArgs = {
  distinct_on?: InputMaybe<Array<ContentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentsOrderBy>>;
  where?: InputMaybe<ContentsBoolExp>;
};

export type QueryRootContentsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentsOrderBy>>;
  where?: InputMaybe<ContentsBoolExp>;
};

export type QueryRootContentsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootCountriesArgs = {
  distinct_on?: InputMaybe<Array<CountriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CountriesOrderBy>>;
  where?: InputMaybe<CountriesBoolExp>;
};

export type QueryRootCountriesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CountriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CountriesOrderBy>>;
  where?: InputMaybe<CountriesBoolExp>;
};

export type QueryRootCountriesByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCustomerPaymentsArgs = {
  distinct_on?: InputMaybe<Array<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

export type QueryRootCustomerPaymentsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

export type QueryRootCustomerPaymentsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCustomerProcessedWebhooksArgs = {
  distinct_on?: InputMaybe<Array<CustomerProcessedWebhooksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerProcessedWebhooksOrderBy>>;
  where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
};

export type QueryRootCustomerProcessedWebhooksAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerProcessedWebhooksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerProcessedWebhooksOrderBy>>;
  where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
};

export type QueryRootCustomerProcessedWebhooksByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCustomerRefundsArgs = {
  distinct_on?: InputMaybe<Array<CustomerRefundsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerRefundsOrderBy>>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
};

export type QueryRootCustomerRefundsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerRefundsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerRefundsOrderBy>>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
};

export type QueryRootCustomerRefundsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCustomerSubscriptionPlansArgs = {
  distinct_on?: InputMaybe<Array<CustomerSubscriptionPlansSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerSubscriptionPlansOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
};

export type QueryRootCustomerSubscriptionPlansAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerSubscriptionPlansSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerSubscriptionPlansOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
};

export type QueryRootCustomerSubscriptionPlansByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCustomerSubscriptionsArgs = {
  distinct_on?: InputMaybe<Array<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

export type QueryRootCustomerSubscriptionsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

export type QueryRootCustomerSubscriptionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootEmbeddingReviewsArgs = {
  distinct_on?: InputMaybe<Array<EmbeddingReviewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<EmbeddingReviewsOrderBy>>;
  where?: InputMaybe<EmbeddingReviewsBoolExp>;
};

export type QueryRootEmbeddingReviewsAggregateArgs = {
  distinct_on?: InputMaybe<Array<EmbeddingReviewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<EmbeddingReviewsOrderBy>>;
  where?: InputMaybe<EmbeddingReviewsBoolExp>;
};

export type QueryRootEmbeddingReviewsByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootErrorCorrelationsArgs = {
  distinct_on?: InputMaybe<Array<ErrorCorrelationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorCorrelationsOrderBy>>;
  where?: InputMaybe<ErrorCorrelationsBoolExp>;
};

export type QueryRootErrorCorrelationsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ErrorCorrelationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorCorrelationsOrderBy>>;
  where?: InputMaybe<ErrorCorrelationsBoolExp>;
};

export type QueryRootErrorFrequencyArgs = {
  distinct_on?: InputMaybe<Array<ErrorFrequencySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorFrequencyOrderBy>>;
  where?: InputMaybe<ErrorFrequencyBoolExp>;
};

export type QueryRootErrorFrequencyAggregateArgs = {
  distinct_on?: InputMaybe<Array<ErrorFrequencySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorFrequencyOrderBy>>;
  where?: InputMaybe<ErrorFrequencyBoolExp>;
};

export type QueryRootErrorLogsArgs = {
  distinct_on?: InputMaybe<Array<ErrorLogsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorLogsOrderBy>>;
  where?: InputMaybe<ErrorLogsBoolExp>;
};

export type QueryRootErrorLogsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ErrorLogsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorLogsOrderBy>>;
  where?: InputMaybe<ErrorLogsBoolExp>;
};

export type QueryRootErrorLogsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootErrorMetricsArgs = {
  distinct_on?: InputMaybe<Array<ErrorMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorMetricsOrderBy>>;
  where?: InputMaybe<ErrorMetricsBoolExp>;
};

export type QueryRootErrorMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ErrorMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorMetricsOrderBy>>;
  where?: InputMaybe<ErrorMetricsBoolExp>;
};

export type QueryRootErrorPatternsArgs = {
  distinct_on?: InputMaybe<Array<ErrorPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorPatternsOrderBy>>;
  where?: InputMaybe<ErrorPatternsBoolExp>;
};

export type QueryRootErrorPatternsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ErrorPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorPatternsOrderBy>>;
  where?: InputMaybe<ErrorPatternsBoolExp>;
};

export type QueryRootErrorStatsArgs = {
  distinct_on?: InputMaybe<Array<ErrorStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorStatsOrderBy>>;
  where?: InputMaybe<ErrorStatsBoolExp>;
};

export type QueryRootErrorStatsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ErrorStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorStatsOrderBy>>;
  where?: InputMaybe<ErrorStatsBoolExp>;
};

export type QueryRootFeatureRequestsArgs = {
  distinct_on?: InputMaybe<Array<FeatureRequestsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeatureRequestsOrderBy>>;
  where?: InputMaybe<FeatureRequestsBoolExp>;
};

export type QueryRootFeatureRequestsAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeatureRequestsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeatureRequestsOrderBy>>;
  where?: InputMaybe<FeatureRequestsBoolExp>;
};

export type QueryRootFeatureRequestsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootFeatureVotesArgs = {
  distinct_on?: InputMaybe<Array<FeatureVotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeatureVotesOrderBy>>;
  where?: InputMaybe<FeatureVotesBoolExp>;
};

export type QueryRootFeatureVotesAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeatureVotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeatureVotesOrderBy>>;
  where?: InputMaybe<FeatureVotesBoolExp>;
};

export type QueryRootFeatureVotesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootFeedCategoriesArgs = {
  distinct_on?: InputMaybe<Array<FeedCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedCategoriesOrderBy>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

export type QueryRootFeedCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeedCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedCategoriesOrderBy>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

export type QueryRootFeedCategoriesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootFeedSourcesArgs = {
  distinct_on?: InputMaybe<Array<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

export type QueryRootFeedSourcesAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

export type QueryRootFeedSourcesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootFeedbacksArgs = {
  distinct_on?: InputMaybe<Array<FeedbacksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedbacksOrderBy>>;
  where?: InputMaybe<FeedbacksBoolExp>;
};

export type QueryRootFeedbacksAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeedbacksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedbacksOrderBy>>;
  where?: InputMaybe<FeedbacksBoolExp>;
};

export type QueryRootFeedbacksByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootFeedsArgs = {
  distinct_on?: InputMaybe<Array<FeedsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedsOrderBy>>;
  where?: InputMaybe<FeedsBoolExp>;
};

export type QueryRootFeedsAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeedsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedsOrderBy>>;
  where?: InputMaybe<FeedsBoolExp>;
};

export type QueryRootFeedsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootFollowsArgs = {
  distinct_on?: InputMaybe<Array<FollowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FollowsOrderBy>>;
  where?: InputMaybe<FollowsBoolExp>;
};

export type QueryRootFollowsAggregateArgs = {
  distinct_on?: InputMaybe<Array<FollowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FollowsOrderBy>>;
  where?: InputMaybe<FollowsBoolExp>;
};

export type QueryRootFollowsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootMetricDefinitionsArgs = {
  distinct_on?: InputMaybe<Array<MetricDefinitionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<MetricDefinitionsOrderBy>>;
  where?: InputMaybe<MetricDefinitionsBoolExp>;
};

export type QueryRootMetricDefinitionsAggregateArgs = {
  distinct_on?: InputMaybe<Array<MetricDefinitionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<MetricDefinitionsOrderBy>>;
  where?: InputMaybe<MetricDefinitionsBoolExp>;
};

export type QueryRootMetricDefinitionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootNewsArgs = {
  distinct_on?: InputMaybe<Array<NewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsOrderBy>>;
  where?: InputMaybe<NewsBoolExp>;
};

export type QueryRootNewsAggregateArgs = {
  distinct_on?: InputMaybe<Array<NewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsOrderBy>>;
  where?: InputMaybe<NewsBoolExp>;
};

export type QueryRootNewsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootNewsDetailsArgs = {
  distinct_on?: InputMaybe<Array<NewsDetailsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsDetailsOrderBy>>;
  where?: InputMaybe<NewsDetailsBoolExp>;
};

export type QueryRootNewsDetailsAggregateArgs = {
  distinct_on?: InputMaybe<Array<NewsDetailsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsDetailsOrderBy>>;
  where?: InputMaybe<NewsDetailsBoolExp>;
};

export type QueryRootNewsSummariesArgs = {
  distinct_on?: InputMaybe<Array<NewsSummariesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsSummariesOrderBy>>;
  where?: InputMaybe<NewsSummariesBoolExp>;
};

export type QueryRootNewsSummariesAggregateArgs = {
  distinct_on?: InputMaybe<Array<NewsSummariesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsSummariesOrderBy>>;
  where?: InputMaybe<NewsSummariesBoolExp>;
};

export type QueryRootNewsSummariesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootNewsTagsArgs = {
  distinct_on?: InputMaybe<Array<NewsTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsTagsOrderBy>>;
  where?: InputMaybe<NewsTagsBoolExp>;
};

export type QueryRootNewsTagsAggregateArgs = {
  distinct_on?: InputMaybe<Array<NewsTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsTagsOrderBy>>;
  where?: InputMaybe<NewsTagsBoolExp>;
};

export type QueryRootNewsTagsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootNewslettersArgs = {
  distinct_on?: InputMaybe<Array<NewslettersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewslettersOrderBy>>;
  where?: InputMaybe<NewslettersBoolExp>;
};

export type QueryRootNewslettersAggregateArgs = {
  distinct_on?: InputMaybe<Array<NewslettersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewslettersOrderBy>>;
  where?: InputMaybe<NewslettersBoolExp>;
};

export type QueryRootNewslettersByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootPaymentProvidersArgs = {
  distinct_on?: InputMaybe<Array<PaymentProvidersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<PaymentProvidersOrderBy>>;
  where?: InputMaybe<PaymentProvidersBoolExp>;
};

export type QueryRootPaymentProvidersAggregateArgs = {
  distinct_on?: InputMaybe<Array<PaymentProvidersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<PaymentProvidersOrderBy>>;
  where?: InputMaybe<PaymentProvidersBoolExp>;
};

export type QueryRootPaymentProvidersByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootPlanPermissionsArgs = {
  distinct_on?: InputMaybe<Array<PlanPermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<PlanPermissionsOrderBy>>;
  where?: InputMaybe<PlanPermissionsBoolExp>;
};

export type QueryRootPlanPermissionsAggregateArgs = {
  distinct_on?: InputMaybe<Array<PlanPermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<PlanPermissionsOrderBy>>;
  where?: InputMaybe<PlanPermissionsBoolExp>;
};

export type QueryRootPlanPermissionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootRecentErrorsArgs = {
  distinct_on?: InputMaybe<Array<RecentErrorsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RecentErrorsOrderBy>>;
  where?: InputMaybe<RecentErrorsBoolExp>;
};

export type QueryRootRecentErrorsAggregateArgs = {
  distinct_on?: InputMaybe<Array<RecentErrorsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RecentErrorsOrderBy>>;
  where?: InputMaybe<RecentErrorsBoolExp>;
};

export type QueryRootReferralStatsArgs = {
  distinct_on?: InputMaybe<Array<ReferralStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferralStatsOrderBy>>;
  where?: InputMaybe<ReferralStatsBoolExp>;
};

export type QueryRootReferralStatsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ReferralStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferralStatsOrderBy>>;
  where?: InputMaybe<ReferralStatsBoolExp>;
};

export type QueryRootReferralsArgs = {
  distinct_on?: InputMaybe<Array<ReferralsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferralsOrderBy>>;
  where?: InputMaybe<ReferralsBoolExp>;
};

export type QueryRootReferralsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ReferralsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferralsOrderBy>>;
  where?: InputMaybe<ReferralsBoolExp>;
};

export type QueryRootReferralsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootReferrerBlocksArgs = {
  distinct_on?: InputMaybe<Array<ReferrerBlocksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferrerBlocksOrderBy>>;
  where?: InputMaybe<ReferrerBlocksBoolExp>;
};

export type QueryRootReferrerBlocksAggregateArgs = {
  distinct_on?: InputMaybe<Array<ReferrerBlocksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferrerBlocksOrderBy>>;
  where?: InputMaybe<ReferrerBlocksBoolExp>;
};

export type QueryRootReferrerBlocksByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootReferrerRiskMetricsArgs = {
  distinct_on?: InputMaybe<Array<ReferrerRiskMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferrerRiskMetricsOrderBy>>;
  where?: InputMaybe<ReferrerRiskMetricsBoolExp>;
};

export type QueryRootReferrerRiskMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ReferrerRiskMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferrerRiskMetricsOrderBy>>;
  where?: InputMaybe<ReferrerRiskMetricsBoolExp>;
};

export type QueryRootResearchArgs = {
  distinct_on?: InputMaybe<Array<ResearchSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResearchOrderBy>>;
  where?: InputMaybe<ResearchBoolExp>;
};

export type QueryRootResearchAggregateArgs = {
  distinct_on?: InputMaybe<Array<ResearchSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResearchOrderBy>>;
  where?: InputMaybe<ResearchBoolExp>;
};

export type QueryRootResearchByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootResearchEmbeddingsArgs = {
  distinct_on?: InputMaybe<Array<ResearchEmbeddingsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResearchEmbeddingsOrderBy>>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

export type QueryRootResearchEmbeddingsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ResearchEmbeddingsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResearchEmbeddingsOrderBy>>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

export type QueryRootResearchEmbeddingsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootResponsesArgs = {
  distinct_on?: InputMaybe<Array<ResponsesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResponsesOrderBy>>;
  where?: InputMaybe<ResponsesBoolExp>;
};

export type QueryRootResponsesAggregateArgs = {
  distinct_on?: InputMaybe<Array<ResponsesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResponsesOrderBy>>;
  where?: InputMaybe<ResponsesBoolExp>;
};

export type QueryRootResponsesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootRoleHierarchyArgs = {
  distinct_on?: InputMaybe<Array<RoleHierarchySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RoleHierarchyOrderBy>>;
  where?: InputMaybe<RoleHierarchyBoolExp>;
};

export type QueryRootRoleHierarchyAggregateArgs = {
  distinct_on?: InputMaybe<Array<RoleHierarchySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RoleHierarchyOrderBy>>;
  where?: InputMaybe<RoleHierarchyBoolExp>;
};

export type QueryRootRoleHierarchyByPkArgs = {
  child_role: Scalars["app_role_enum"]["input"];
  parent_role: Scalars["app_role_enum"]["input"];
};

export type QueryRootRolePermissionsArgs = {
  distinct_on?: InputMaybe<Array<RolePermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RolePermissionsOrderBy>>;
  where?: InputMaybe<RolePermissionsBoolExp>;
};

export type QueryRootRolePermissionsAggregateArgs = {
  distinct_on?: InputMaybe<Array<RolePermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RolePermissionsOrderBy>>;
  where?: InputMaybe<RolePermissionsBoolExp>;
};

export type QueryRootRolePermissionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootRolePermissionsMaterializedArgs = {
  distinct_on?: InputMaybe<Array<RolePermissionsMaterializedSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RolePermissionsMaterializedOrderBy>>;
  where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
};

export type QueryRootRolePermissionsMaterializedAggregateArgs = {
  distinct_on?: InputMaybe<Array<RolePermissionsMaterializedSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RolePermissionsMaterializedOrderBy>>;
  where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
};

export type QueryRootRolePermissionsMaterializedByPkArgs = {
  role: Scalars["app_role_enum"]["input"];
};

export type QueryRootScoringWeightsArgs = {
  distinct_on?: InputMaybe<Array<ScoringWeightsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ScoringWeightsOrderBy>>;
  where?: InputMaybe<ScoringWeightsBoolExp>;
};

export type QueryRootScoringWeightsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ScoringWeightsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ScoringWeightsOrderBy>>;
  where?: InputMaybe<ScoringWeightsBoolExp>;
};

export type QueryRootScoringWeightsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootSearchesArgs = {
  distinct_on?: InputMaybe<Array<SearchesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SearchesOrderBy>>;
  where?: InputMaybe<SearchesBoolExp>;
};

export type QueryRootSearchesAggregateArgs = {
  distinct_on?: InputMaybe<Array<SearchesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SearchesOrderBy>>;
  where?: InputMaybe<SearchesBoolExp>;
};

export type QueryRootSearchesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootSecurityMetricsArgs = {
  distinct_on?: InputMaybe<Array<SecurityMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SecurityMetricsOrderBy>>;
  where?: InputMaybe<SecurityMetricsBoolExp>;
};

export type QueryRootSecurityMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<SecurityMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SecurityMetricsOrderBy>>;
  where?: InputMaybe<SecurityMetricsBoolExp>;
};

export type QueryRootSlowQueryPatternsArgs = {
  distinct_on?: InputMaybe<Array<SlowQueryPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SlowQueryPatternsOrderBy>>;
  where?: InputMaybe<SlowQueryPatternsBoolExp>;
};

export type QueryRootSlowQueryPatternsAggregateArgs = {
  distinct_on?: InputMaybe<Array<SlowQueryPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SlowQueryPatternsOrderBy>>;
  where?: InputMaybe<SlowQueryPatternsBoolExp>;
};

export type QueryRootSocialMediaArgs = {
  distinct_on?: InputMaybe<Array<SocialMediaSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SocialMediaOrderBy>>;
  where?: InputMaybe<SocialMediaBoolExp>;
};

export type QueryRootSocialMediaAggregateArgs = {
  distinct_on?: InputMaybe<Array<SocialMediaSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SocialMediaOrderBy>>;
  where?: InputMaybe<SocialMediaBoolExp>;
};

export type QueryRootSocialMediaByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootSpiderMetricsArgs = {
  distinct_on?: InputMaybe<Array<SpiderMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SpiderMetricsOrderBy>>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
};

export type QueryRootSpiderMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<SpiderMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SpiderMetricsOrderBy>>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
};

export type QueryRootSpiderMetricsByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootStrapiMigrationsArgs = {
  distinct_on?: InputMaybe<Array<StrapiMigrationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<StrapiMigrationsOrderBy>>;
  where?: InputMaybe<StrapiMigrationsBoolExp>;
};

export type QueryRootStrapiMigrationsAggregateArgs = {
  distinct_on?: InputMaybe<Array<StrapiMigrationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<StrapiMigrationsOrderBy>>;
  where?: InputMaybe<StrapiMigrationsBoolExp>;
};

export type QueryRootStrapiMigrationsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootStrapiMigrationsInternalArgs = {
  distinct_on?: InputMaybe<Array<StrapiMigrationsInternalSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<StrapiMigrationsInternalOrderBy>>;
  where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
};

export type QueryRootStrapiMigrationsInternalAggregateArgs = {
  distinct_on?: InputMaybe<Array<StrapiMigrationsInternalSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<StrapiMigrationsInternalOrderBy>>;
  where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
};

export type QueryRootStrapiMigrationsInternalByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootTableMaintenanceLogArgs = {
  distinct_on?: InputMaybe<Array<TableMaintenanceLogSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableMaintenanceLogOrderBy>>;
  where?: InputMaybe<TableMaintenanceLogBoolExp>;
};

export type QueryRootTableMaintenanceLogAggregateArgs = {
  distinct_on?: InputMaybe<Array<TableMaintenanceLogSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableMaintenanceLogOrderBy>>;
  where?: InputMaybe<TableMaintenanceLogBoolExp>;
};

export type QueryRootTableMaintenanceLogByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootTableQueryPerformanceArgs = {
  distinct_on?: InputMaybe<Array<TableQueryPerformanceSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableQueryPerformanceOrderBy>>;
  where?: InputMaybe<TableQueryPerformanceBoolExp>;
};

export type QueryRootTableQueryPerformanceAggregateArgs = {
  distinct_on?: InputMaybe<Array<TableQueryPerformanceSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableQueryPerformanceOrderBy>>;
  where?: InputMaybe<TableQueryPerformanceBoolExp>;
};

export type QueryRootTableSequenceUsageArgs = {
  distinct_on?: InputMaybe<Array<TableSequenceUsageSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableSequenceUsageOrderBy>>;
  where?: InputMaybe<TableSequenceUsageBoolExp>;
};

export type QueryRootTableSequenceUsageAggregateArgs = {
  distinct_on?: InputMaybe<Array<TableSequenceUsageSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableSequenceUsageOrderBy>>;
  where?: InputMaybe<TableSequenceUsageBoolExp>;
};

export type QueryRootTableStatisticsArgs = {
  distinct_on?: InputMaybe<Array<TableStatisticsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableStatisticsOrderBy>>;
  where?: InputMaybe<TableStatisticsBoolExp>;
};

export type QueryRootTableStatisticsAggregateArgs = {
  distinct_on?: InputMaybe<Array<TableStatisticsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableStatisticsOrderBy>>;
  where?: InputMaybe<TableStatisticsBoolExp>;
};

export type QueryRootTableStatisticsByPkArgs = {
  capture_time: Scalars["timestamptz"]["input"];
  table_name: Scalars["String"]["input"];
};

export type QueryRootTagsArgs = {
  distinct_on?: InputMaybe<Array<TagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TagsOrderBy>>;
  where?: InputMaybe<TagsBoolExp>;
};

export type QueryRootTagsAggregateArgs = {
  distinct_on?: InputMaybe<Array<TagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TagsOrderBy>>;
  where?: InputMaybe<TagsBoolExp>;
};

export type QueryRootTagsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootUserMetricsArgs = {
  distinct_on?: InputMaybe<Array<UserMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<UserMetricsOrderBy>>;
  where?: InputMaybe<UserMetricsBoolExp>;
};

export type QueryRootUserMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<UserMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<UserMetricsOrderBy>>;
  where?: InputMaybe<UserMetricsBoolExp>;
};

export type QueryRootUserMetricsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootUserProfilesArgs = {
  distinct_on?: InputMaybe<Array<UserProfilesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<UserProfilesOrderBy>>;
  where?: InputMaybe<UserProfilesBoolExp>;
};

export type QueryRootUserProfilesAggregateArgs = {
  distinct_on?: InputMaybe<Array<UserProfilesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<UserProfilesOrderBy>>;
  where?: InputMaybe<UserProfilesBoolExp>;
};

export type QueryRootUserProfilesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootVotesArgs = {
  distinct_on?: InputMaybe<Array<VotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<VotesOrderBy>>;
  where?: InputMaybe<VotesBoolExp>;
};

export type QueryRootVotesAggregateArgs = {
  distinct_on?: InputMaybe<Array<VotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<VotesOrderBy>>;
  where?: InputMaybe<VotesBoolExp>;
};

export type QueryRootVotesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootWorkflowsArgs = {
  distinct_on?: InputMaybe<Array<WorkflowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<WorkflowsOrderBy>>;
  where?: InputMaybe<WorkflowsBoolExp>;
};

export type QueryRootWorkflowsAggregateArgs = {
  distinct_on?: InputMaybe<Array<WorkflowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<WorkflowsOrderBy>>;
  where?: InputMaybe<WorkflowsBoolExp>;
};

export type QueryRootWorkflowsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** columns and relationships of "recent_errors" */
export type RecentErrors = {
  __typename?: "recent_errors";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  error_type?: Maybe<Scalars["error_type"]["output"]>;
  message?: Maybe<Scalars["String"]["output"]>;
  metadata?: Maybe<Scalars["jsonb"]["output"]>;
  service_name?: Maybe<Scalars["String"]["output"]>;
  severity?: Maybe<Scalars["error_severity"]["output"]>;
};

/** columns and relationships of "recent_errors" */
export type RecentErrorsMetadataArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "recent_errors" */
export type RecentErrorsAggregate = {
  __typename?: "recent_errors_aggregate";
  aggregate?: Maybe<RecentErrorsAggregateFields>;
  nodes: Array<RecentErrors>;
};

/** aggregate fields of "recent_errors" */
export type RecentErrorsAggregateFields = {
  __typename?: "recent_errors_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<RecentErrorsMaxFields>;
  min?: Maybe<RecentErrorsMinFields>;
};

/** aggregate fields of "recent_errors" */
export type RecentErrorsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<RecentErrorsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type RecentErrorsAppendInput = {
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** Boolean expression to filter rows from the table "recent_errors". All fields are combined with a logical 'AND'. */
export type RecentErrorsBoolExp = {
  _and?: InputMaybe<Array<RecentErrorsBoolExp>>;
  _not?: InputMaybe<RecentErrorsBoolExp>;
  _or?: InputMaybe<Array<RecentErrorsBoolExp>>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  error_type?: InputMaybe<ErrorTypeComparisonExp>;
  message?: InputMaybe<StringComparisonExp>;
  metadata?: InputMaybe<JsonbComparisonExp>;
  service_name?: InputMaybe<StringComparisonExp>;
  severity?: InputMaybe<ErrorSeverityComparisonExp>;
};

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type RecentErrorsDeleteAtPathInput = {
  metadata?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type RecentErrorsDeleteElemInput = {
  metadata?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type RecentErrorsDeleteKeyInput = {
  metadata?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for inserting data into table "recent_errors" */
export type RecentErrorsInsertInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  message?: InputMaybe<Scalars["String"]["input"]>;
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  service_name?: InputMaybe<Scalars["String"]["input"]>;
  severity?: InputMaybe<Scalars["error_severity"]["input"]>;
};

/** aggregate max on columns */
export type RecentErrorsMaxFields = {
  __typename?: "recent_errors_max_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  error_type?: Maybe<Scalars["error_type"]["output"]>;
  message?: Maybe<Scalars["String"]["output"]>;
  service_name?: Maybe<Scalars["String"]["output"]>;
  severity?: Maybe<Scalars["error_severity"]["output"]>;
};

/** aggregate min on columns */
export type RecentErrorsMinFields = {
  __typename?: "recent_errors_min_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  error_type?: Maybe<Scalars["error_type"]["output"]>;
  message?: Maybe<Scalars["String"]["output"]>;
  service_name?: Maybe<Scalars["String"]["output"]>;
  severity?: Maybe<Scalars["error_severity"]["output"]>;
};

/** response of any mutation on the table "recent_errors" */
export type RecentErrorsMutationResponse = {
  __typename?: "recent_errors_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<RecentErrors>;
};

/** Ordering options when selecting data from "recent_errors". */
export type RecentErrorsOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  error_type?: InputMaybe<OrderBy>;
  message?: InputMaybe<OrderBy>;
  metadata?: InputMaybe<OrderBy>;
  service_name?: InputMaybe<OrderBy>;
  severity?: InputMaybe<OrderBy>;
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type RecentErrorsPrependInput = {
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "recent_errors" */
export enum RecentErrorsSelectColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ERROR_TYPE = "error_type",
  /** column name */
  MESSAGE = "message",
  /** column name */
  METADATA = "metadata",
  /** column name */
  SERVICE_NAME = "service_name",
  /** column name */
  SEVERITY = "severity",
}

/** input type for updating data in table "recent_errors" */
export type RecentErrorsSetInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  message?: InputMaybe<Scalars["String"]["input"]>;
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  service_name?: InputMaybe<Scalars["String"]["input"]>;
  severity?: InputMaybe<Scalars["error_severity"]["input"]>;
};

/** Streaming cursor of the table "recent_errors" */
export type RecentErrorsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: RecentErrorsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type RecentErrorsStreamCursorValueInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  message?: InputMaybe<Scalars["String"]["input"]>;
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  service_name?: InputMaybe<Scalars["String"]["input"]>;
  severity?: InputMaybe<Scalars["error_severity"]["input"]>;
};

export type RecentErrorsUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<RecentErrorsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<RecentErrorsDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<RecentErrorsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<RecentErrorsDeleteKeyInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<RecentErrorsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<RecentErrorsSetInput>;
  /** filter the rows which have to be updated */
  where: RecentErrorsBoolExp;
};

/** columns and relationships of "referral_stats" */
export type ReferralStats = {
  __typename?: "referral_stats";
  active_days?: Maybe<Scalars["bigint"]["output"]>;
  avg_conversion_time_hours?: Maybe<Scalars["numeric"]["output"]>;
  conversion_rate?: Maybe<Scalars["numeric"]["output"]>;
  conversions?: Maybe<Scalars["bigint"]["output"]>;
  referrer_code?: Maybe<Scalars["String"]["output"]>;
  total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  total_value?: Maybe<Scalars["numeric"]["output"]>;
  unique_visitors?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregated selection of "referral_stats" */
export type ReferralStatsAggregate = {
  __typename?: "referral_stats_aggregate";
  aggregate?: Maybe<ReferralStatsAggregateFields>;
  nodes: Array<ReferralStats>;
};

/** aggregate fields of "referral_stats" */
export type ReferralStatsAggregateFields = {
  __typename?: "referral_stats_aggregate_fields";
  avg?: Maybe<ReferralStatsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ReferralStatsMaxFields>;
  min?: Maybe<ReferralStatsMinFields>;
  stddev?: Maybe<ReferralStatsStddevFields>;
  stddev_pop?: Maybe<ReferralStatsStddevPopFields>;
  stddev_samp?: Maybe<ReferralStatsStddevSampFields>;
  sum?: Maybe<ReferralStatsSumFields>;
  var_pop?: Maybe<ReferralStatsVarPopFields>;
  var_samp?: Maybe<ReferralStatsVarSampFields>;
  variance?: Maybe<ReferralStatsVarianceFields>;
};

/** aggregate fields of "referral_stats" */
export type ReferralStatsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ReferralStatsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type ReferralStatsAvgFields = {
  __typename?: "referral_stats_avg_fields";
  active_days?: Maybe<Scalars["Float"]["output"]>;
  avg_conversion_time_hours?: Maybe<Scalars["Float"]["output"]>;
  conversion_rate?: Maybe<Scalars["Float"]["output"]>;
  conversions?: Maybe<Scalars["Float"]["output"]>;
  total_referrals?: Maybe<Scalars["Float"]["output"]>;
  total_value?: Maybe<Scalars["Float"]["output"]>;
  unique_visitors?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "referral_stats". All fields are combined with a logical 'AND'. */
export type ReferralStatsBoolExp = {
  _and?: InputMaybe<Array<ReferralStatsBoolExp>>;
  _not?: InputMaybe<ReferralStatsBoolExp>;
  _or?: InputMaybe<Array<ReferralStatsBoolExp>>;
  active_days?: InputMaybe<BigintComparisonExp>;
  avg_conversion_time_hours?: InputMaybe<NumericComparisonExp>;
  conversion_rate?: InputMaybe<NumericComparisonExp>;
  conversions?: InputMaybe<BigintComparisonExp>;
  referrer_code?: InputMaybe<StringComparisonExp>;
  total_referrals?: InputMaybe<BigintComparisonExp>;
  total_value?: InputMaybe<NumericComparisonExp>;
  unique_visitors?: InputMaybe<BigintComparisonExp>;
};

/** aggregate max on columns */
export type ReferralStatsMaxFields = {
  __typename?: "referral_stats_max_fields";
  active_days?: Maybe<Scalars["bigint"]["output"]>;
  avg_conversion_time_hours?: Maybe<Scalars["numeric"]["output"]>;
  conversion_rate?: Maybe<Scalars["numeric"]["output"]>;
  conversions?: Maybe<Scalars["bigint"]["output"]>;
  referrer_code?: Maybe<Scalars["String"]["output"]>;
  total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  total_value?: Maybe<Scalars["numeric"]["output"]>;
  unique_visitors?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate min on columns */
export type ReferralStatsMinFields = {
  __typename?: "referral_stats_min_fields";
  active_days?: Maybe<Scalars["bigint"]["output"]>;
  avg_conversion_time_hours?: Maybe<Scalars["numeric"]["output"]>;
  conversion_rate?: Maybe<Scalars["numeric"]["output"]>;
  conversions?: Maybe<Scalars["bigint"]["output"]>;
  referrer_code?: Maybe<Scalars["String"]["output"]>;
  total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  total_value?: Maybe<Scalars["numeric"]["output"]>;
  unique_visitors?: Maybe<Scalars["bigint"]["output"]>;
};

/** Ordering options when selecting data from "referral_stats". */
export type ReferralStatsOrderBy = {
  active_days?: InputMaybe<OrderBy>;
  avg_conversion_time_hours?: InputMaybe<OrderBy>;
  conversion_rate?: InputMaybe<OrderBy>;
  conversions?: InputMaybe<OrderBy>;
  referrer_code?: InputMaybe<OrderBy>;
  total_referrals?: InputMaybe<OrderBy>;
  total_value?: InputMaybe<OrderBy>;
  unique_visitors?: InputMaybe<OrderBy>;
};

/** select columns of table "referral_stats" */
export enum ReferralStatsSelectColumn {
  /** column name */
  ACTIVE_DAYS = "active_days",
  /** column name */
  AVG_CONVERSION_TIME_HOURS = "avg_conversion_time_hours",
  /** column name */
  CONVERSION_RATE = "conversion_rate",
  /** column name */
  CONVERSIONS = "conversions",
  /** column name */
  REFERRER_CODE = "referrer_code",
  /** column name */
  TOTAL_REFERRALS = "total_referrals",
  /** column name */
  TOTAL_VALUE = "total_value",
  /** column name */
  UNIQUE_VISITORS = "unique_visitors",
}

/** aggregate stddev on columns */
export type ReferralStatsStddevFields = {
  __typename?: "referral_stats_stddev_fields";
  active_days?: Maybe<Scalars["Float"]["output"]>;
  avg_conversion_time_hours?: Maybe<Scalars["Float"]["output"]>;
  conversion_rate?: Maybe<Scalars["Float"]["output"]>;
  conversions?: Maybe<Scalars["Float"]["output"]>;
  total_referrals?: Maybe<Scalars["Float"]["output"]>;
  total_value?: Maybe<Scalars["Float"]["output"]>;
  unique_visitors?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type ReferralStatsStddevPopFields = {
  __typename?: "referral_stats_stddev_pop_fields";
  active_days?: Maybe<Scalars["Float"]["output"]>;
  avg_conversion_time_hours?: Maybe<Scalars["Float"]["output"]>;
  conversion_rate?: Maybe<Scalars["Float"]["output"]>;
  conversions?: Maybe<Scalars["Float"]["output"]>;
  total_referrals?: Maybe<Scalars["Float"]["output"]>;
  total_value?: Maybe<Scalars["Float"]["output"]>;
  unique_visitors?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type ReferralStatsStddevSampFields = {
  __typename?: "referral_stats_stddev_samp_fields";
  active_days?: Maybe<Scalars["Float"]["output"]>;
  avg_conversion_time_hours?: Maybe<Scalars["Float"]["output"]>;
  conversion_rate?: Maybe<Scalars["Float"]["output"]>;
  conversions?: Maybe<Scalars["Float"]["output"]>;
  total_referrals?: Maybe<Scalars["Float"]["output"]>;
  total_value?: Maybe<Scalars["Float"]["output"]>;
  unique_visitors?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "referral_stats" */
export type ReferralStatsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ReferralStatsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ReferralStatsStreamCursorValueInput = {
  active_days?: InputMaybe<Scalars["bigint"]["input"]>;
  avg_conversion_time_hours?: InputMaybe<Scalars["numeric"]["input"]>;
  conversion_rate?: InputMaybe<Scalars["numeric"]["input"]>;
  conversions?: InputMaybe<Scalars["bigint"]["input"]>;
  referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  total_referrals?: InputMaybe<Scalars["bigint"]["input"]>;
  total_value?: InputMaybe<Scalars["numeric"]["input"]>;
  unique_visitors?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** aggregate sum on columns */
export type ReferralStatsSumFields = {
  __typename?: "referral_stats_sum_fields";
  active_days?: Maybe<Scalars["bigint"]["output"]>;
  avg_conversion_time_hours?: Maybe<Scalars["numeric"]["output"]>;
  conversion_rate?: Maybe<Scalars["numeric"]["output"]>;
  conversions?: Maybe<Scalars["bigint"]["output"]>;
  total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  total_value?: Maybe<Scalars["numeric"]["output"]>;
  unique_visitors?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate var_pop on columns */
export type ReferralStatsVarPopFields = {
  __typename?: "referral_stats_var_pop_fields";
  active_days?: Maybe<Scalars["Float"]["output"]>;
  avg_conversion_time_hours?: Maybe<Scalars["Float"]["output"]>;
  conversion_rate?: Maybe<Scalars["Float"]["output"]>;
  conversions?: Maybe<Scalars["Float"]["output"]>;
  total_referrals?: Maybe<Scalars["Float"]["output"]>;
  total_value?: Maybe<Scalars["Float"]["output"]>;
  unique_visitors?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type ReferralStatsVarSampFields = {
  __typename?: "referral_stats_var_samp_fields";
  active_days?: Maybe<Scalars["Float"]["output"]>;
  avg_conversion_time_hours?: Maybe<Scalars["Float"]["output"]>;
  conversion_rate?: Maybe<Scalars["Float"]["output"]>;
  conversions?: Maybe<Scalars["Float"]["output"]>;
  total_referrals?: Maybe<Scalars["Float"]["output"]>;
  total_value?: Maybe<Scalars["Float"]["output"]>;
  unique_visitors?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type ReferralStatsVarianceFields = {
  __typename?: "referral_stats_variance_fields";
  active_days?: Maybe<Scalars["Float"]["output"]>;
  avg_conversion_time_hours?: Maybe<Scalars["Float"]["output"]>;
  conversion_rate?: Maybe<Scalars["Float"]["output"]>;
  conversions?: Maybe<Scalars["Float"]["output"]>;
  total_referrals?: Maybe<Scalars["Float"]["output"]>;
  total_value?: Maybe<Scalars["Float"]["output"]>;
  unique_visitors?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to compare columns of type "referral_status". All fields are combined with logical 'AND'. */
export type ReferralStatusComparisonExp = {
  _eq?: InputMaybe<Scalars["referral_status"]["input"]>;
  _gt?: InputMaybe<Scalars["referral_status"]["input"]>;
  _gte?: InputMaybe<Scalars["referral_status"]["input"]>;
  _in?: InputMaybe<Array<Scalars["referral_status"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["referral_status"]["input"]>;
  _lte?: InputMaybe<Scalars["referral_status"]["input"]>;
  _neq?: InputMaybe<Scalars["referral_status"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["referral_status"]["input"]>>;
};

/** columns and relationships of "referrals" */
export type Referrals = {
  __typename?: "referrals";
  browser?: Maybe<Scalars["String"]["output"]>;
  client_fingerprint?: Maybe<Scalars["String"]["output"]>;
  conversion_value?: Maybe<Scalars["numeric"]["output"]>;
  converted_at?: Maybe<Scalars["timestamptz"]["output"]>;
  country_code?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  device_type?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["uuid"]["output"];
  ip_address?: Maybe<Scalars["inet"]["output"]>;
  is_suspicious?: Maybe<Scalars["Boolean"]["output"]>;
  landing_page?: Maybe<Scalars["String"]["output"]>;
  last_failed_attempt?: Maybe<Scalars["timestamptz"]["output"]>;
  referral_status?: Maybe<Scalars["referral_status"]["output"]>;
  referrer_code: Scalars["String"]["output"];
  region?: Maybe<Scalars["String"]["output"]>;
  security_flags?: Maybe<Scalars["jsonb"]["output"]>;
  user_agent?: Maybe<Scalars["String"]["output"]>;
  utm_campaign?: Maybe<Scalars["String"]["output"]>;
  utm_medium?: Maybe<Scalars["String"]["output"]>;
  utm_source?: Maybe<Scalars["String"]["output"]>;
  validation_attempts?: Maybe<Scalars["Int"]["output"]>;
  visitor_id: Scalars["uuid"]["output"];
};

/** columns and relationships of "referrals" */
export type ReferralsSecurityFlagsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "referrals" */
export type ReferralsAggregate = {
  __typename?: "referrals_aggregate";
  aggregate?: Maybe<ReferralsAggregateFields>;
  nodes: Array<Referrals>;
};

/** aggregate fields of "referrals" */
export type ReferralsAggregateFields = {
  __typename?: "referrals_aggregate_fields";
  avg?: Maybe<ReferralsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ReferralsMaxFields>;
  min?: Maybe<ReferralsMinFields>;
  stddev?: Maybe<ReferralsStddevFields>;
  stddev_pop?: Maybe<ReferralsStddevPopFields>;
  stddev_samp?: Maybe<ReferralsStddevSampFields>;
  sum?: Maybe<ReferralsSumFields>;
  var_pop?: Maybe<ReferralsVarPopFields>;
  var_samp?: Maybe<ReferralsVarSampFields>;
  variance?: Maybe<ReferralsVarianceFields>;
};

/** aggregate fields of "referrals" */
export type ReferralsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ReferralsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type ReferralsAppendInput = {
  security_flags?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** aggregate avg on columns */
export type ReferralsAvgFields = {
  __typename?: "referrals_avg_fields";
  conversion_value?: Maybe<Scalars["Float"]["output"]>;
  validation_attempts?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "referrals". All fields are combined with a logical 'AND'. */
export type ReferralsBoolExp = {
  _and?: InputMaybe<Array<ReferralsBoolExp>>;
  _not?: InputMaybe<ReferralsBoolExp>;
  _or?: InputMaybe<Array<ReferralsBoolExp>>;
  browser?: InputMaybe<StringComparisonExp>;
  client_fingerprint?: InputMaybe<StringComparisonExp>;
  conversion_value?: InputMaybe<NumericComparisonExp>;
  converted_at?: InputMaybe<TimestamptzComparisonExp>;
  country_code?: InputMaybe<StringComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  device_type?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  ip_address?: InputMaybe<InetComparisonExp>;
  is_suspicious?: InputMaybe<BooleanComparisonExp>;
  landing_page?: InputMaybe<StringComparisonExp>;
  last_failed_attempt?: InputMaybe<TimestamptzComparisonExp>;
  referral_status?: InputMaybe<ReferralStatusComparisonExp>;
  referrer_code?: InputMaybe<StringComparisonExp>;
  region?: InputMaybe<StringComparisonExp>;
  security_flags?: InputMaybe<JsonbComparisonExp>;
  user_agent?: InputMaybe<StringComparisonExp>;
  utm_campaign?: InputMaybe<StringComparisonExp>;
  utm_medium?: InputMaybe<StringComparisonExp>;
  utm_source?: InputMaybe<StringComparisonExp>;
  validation_attempts?: InputMaybe<IntComparisonExp>;
  visitor_id?: InputMaybe<UuidComparisonExp>;
};

/** unique or primary key constraints on table "referrals" */
export enum ReferralsConstraint {
  /** unique or primary key constraint on columns "id" */
  REFERRALS_PKEY = "referrals_pkey",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type ReferralsDeleteAtPathInput = {
  security_flags?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type ReferralsDeleteElemInput = {
  security_flags?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type ReferralsDeleteKeyInput = {
  security_flags?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for incrementing numeric columns in table "referrals" */
export type ReferralsIncInput = {
  conversion_value?: InputMaybe<Scalars["numeric"]["input"]>;
  validation_attempts?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "referrals" */
export type ReferralsInsertInput = {
  browser?: InputMaybe<Scalars["String"]["input"]>;
  client_fingerprint?: InputMaybe<Scalars["String"]["input"]>;
  conversion_value?: InputMaybe<Scalars["numeric"]["input"]>;
  converted_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  country_code?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  device_type?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  ip_address?: InputMaybe<Scalars["inet"]["input"]>;
  is_suspicious?: InputMaybe<Scalars["Boolean"]["input"]>;
  landing_page?: InputMaybe<Scalars["String"]["input"]>;
  last_failed_attempt?: InputMaybe<Scalars["timestamptz"]["input"]>;
  referral_status?: InputMaybe<Scalars["referral_status"]["input"]>;
  referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  region?: InputMaybe<Scalars["String"]["input"]>;
  security_flags?: InputMaybe<Scalars["jsonb"]["input"]>;
  user_agent?: InputMaybe<Scalars["String"]["input"]>;
  utm_campaign?: InputMaybe<Scalars["String"]["input"]>;
  utm_medium?: InputMaybe<Scalars["String"]["input"]>;
  utm_source?: InputMaybe<Scalars["String"]["input"]>;
  validation_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  visitor_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate max on columns */
export type ReferralsMaxFields = {
  __typename?: "referrals_max_fields";
  browser?: Maybe<Scalars["String"]["output"]>;
  client_fingerprint?: Maybe<Scalars["String"]["output"]>;
  conversion_value?: Maybe<Scalars["numeric"]["output"]>;
  converted_at?: Maybe<Scalars["timestamptz"]["output"]>;
  country_code?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  device_type?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  landing_page?: Maybe<Scalars["String"]["output"]>;
  last_failed_attempt?: Maybe<Scalars["timestamptz"]["output"]>;
  referral_status?: Maybe<Scalars["referral_status"]["output"]>;
  referrer_code?: Maybe<Scalars["String"]["output"]>;
  region?: Maybe<Scalars["String"]["output"]>;
  user_agent?: Maybe<Scalars["String"]["output"]>;
  utm_campaign?: Maybe<Scalars["String"]["output"]>;
  utm_medium?: Maybe<Scalars["String"]["output"]>;
  utm_source?: Maybe<Scalars["String"]["output"]>;
  validation_attempts?: Maybe<Scalars["Int"]["output"]>;
  visitor_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** aggregate min on columns */
export type ReferralsMinFields = {
  __typename?: "referrals_min_fields";
  browser?: Maybe<Scalars["String"]["output"]>;
  client_fingerprint?: Maybe<Scalars["String"]["output"]>;
  conversion_value?: Maybe<Scalars["numeric"]["output"]>;
  converted_at?: Maybe<Scalars["timestamptz"]["output"]>;
  country_code?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  device_type?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  landing_page?: Maybe<Scalars["String"]["output"]>;
  last_failed_attempt?: Maybe<Scalars["timestamptz"]["output"]>;
  referral_status?: Maybe<Scalars["referral_status"]["output"]>;
  referrer_code?: Maybe<Scalars["String"]["output"]>;
  region?: Maybe<Scalars["String"]["output"]>;
  user_agent?: Maybe<Scalars["String"]["output"]>;
  utm_campaign?: Maybe<Scalars["String"]["output"]>;
  utm_medium?: Maybe<Scalars["String"]["output"]>;
  utm_source?: Maybe<Scalars["String"]["output"]>;
  validation_attempts?: Maybe<Scalars["Int"]["output"]>;
  visitor_id?: Maybe<Scalars["uuid"]["output"]>;
};

/** response of any mutation on the table "referrals" */
export type ReferralsMutationResponse = {
  __typename?: "referrals_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Referrals>;
};

/** on_conflict condition type for table "referrals" */
export type ReferralsOnConflict = {
  constraint: ReferralsConstraint;
  update_columns?: Array<ReferralsUpdateColumn>;
  where?: InputMaybe<ReferralsBoolExp>;
};

/** Ordering options when selecting data from "referrals". */
export type ReferralsOrderBy = {
  browser?: InputMaybe<OrderBy>;
  client_fingerprint?: InputMaybe<OrderBy>;
  conversion_value?: InputMaybe<OrderBy>;
  converted_at?: InputMaybe<OrderBy>;
  country_code?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  device_type?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  ip_address?: InputMaybe<OrderBy>;
  is_suspicious?: InputMaybe<OrderBy>;
  landing_page?: InputMaybe<OrderBy>;
  last_failed_attempt?: InputMaybe<OrderBy>;
  referral_status?: InputMaybe<OrderBy>;
  referrer_code?: InputMaybe<OrderBy>;
  region?: InputMaybe<OrderBy>;
  security_flags?: InputMaybe<OrderBy>;
  user_agent?: InputMaybe<OrderBy>;
  utm_campaign?: InputMaybe<OrderBy>;
  utm_medium?: InputMaybe<OrderBy>;
  utm_source?: InputMaybe<OrderBy>;
  validation_attempts?: InputMaybe<OrderBy>;
  visitor_id?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: referrals */
export type ReferralsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type ReferralsPrependInput = {
  security_flags?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "referrals" */
export enum ReferralsSelectColumn {
  /** column name */
  BROWSER = "browser",
  /** column name */
  CLIENT_FINGERPRINT = "client_fingerprint",
  /** column name */
  CONVERSION_VALUE = "conversion_value",
  /** column name */
  CONVERTED_AT = "converted_at",
  /** column name */
  COUNTRY_CODE = "country_code",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DEVICE_TYPE = "device_type",
  /** column name */
  ID = "id",
  /** column name */
  IP_ADDRESS = "ip_address",
  /** column name */
  IS_SUSPICIOUS = "is_suspicious",
  /** column name */
  LANDING_PAGE = "landing_page",
  /** column name */
  LAST_FAILED_ATTEMPT = "last_failed_attempt",
  /** column name */
  REFERRAL_STATUS = "referral_status",
  /** column name */
  REFERRER_CODE = "referrer_code",
  /** column name */
  REGION = "region",
  /** column name */
  SECURITY_FLAGS = "security_flags",
  /** column name */
  USER_AGENT = "user_agent",
  /** column name */
  UTM_CAMPAIGN = "utm_campaign",
  /** column name */
  UTM_MEDIUM = "utm_medium",
  /** column name */
  UTM_SOURCE = "utm_source",
  /** column name */
  VALIDATION_ATTEMPTS = "validation_attempts",
  /** column name */
  VISITOR_ID = "visitor_id",
}

/** input type for updating data in table "referrals" */
export type ReferralsSetInput = {
  browser?: InputMaybe<Scalars["String"]["input"]>;
  client_fingerprint?: InputMaybe<Scalars["String"]["input"]>;
  conversion_value?: InputMaybe<Scalars["numeric"]["input"]>;
  converted_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  country_code?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  device_type?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  ip_address?: InputMaybe<Scalars["inet"]["input"]>;
  is_suspicious?: InputMaybe<Scalars["Boolean"]["input"]>;
  landing_page?: InputMaybe<Scalars["String"]["input"]>;
  last_failed_attempt?: InputMaybe<Scalars["timestamptz"]["input"]>;
  referral_status?: InputMaybe<Scalars["referral_status"]["input"]>;
  referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  region?: InputMaybe<Scalars["String"]["input"]>;
  security_flags?: InputMaybe<Scalars["jsonb"]["input"]>;
  user_agent?: InputMaybe<Scalars["String"]["input"]>;
  utm_campaign?: InputMaybe<Scalars["String"]["input"]>;
  utm_medium?: InputMaybe<Scalars["String"]["input"]>;
  utm_source?: InputMaybe<Scalars["String"]["input"]>;
  validation_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  visitor_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate stddev on columns */
export type ReferralsStddevFields = {
  __typename?: "referrals_stddev_fields";
  conversion_value?: Maybe<Scalars["Float"]["output"]>;
  validation_attempts?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type ReferralsStddevPopFields = {
  __typename?: "referrals_stddev_pop_fields";
  conversion_value?: Maybe<Scalars["Float"]["output"]>;
  validation_attempts?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type ReferralsStddevSampFields = {
  __typename?: "referrals_stddev_samp_fields";
  conversion_value?: Maybe<Scalars["Float"]["output"]>;
  validation_attempts?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "referrals" */
export type ReferralsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ReferralsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ReferralsStreamCursorValueInput = {
  browser?: InputMaybe<Scalars["String"]["input"]>;
  client_fingerprint?: InputMaybe<Scalars["String"]["input"]>;
  conversion_value?: InputMaybe<Scalars["numeric"]["input"]>;
  converted_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  country_code?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  device_type?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  ip_address?: InputMaybe<Scalars["inet"]["input"]>;
  is_suspicious?: InputMaybe<Scalars["Boolean"]["input"]>;
  landing_page?: InputMaybe<Scalars["String"]["input"]>;
  last_failed_attempt?: InputMaybe<Scalars["timestamptz"]["input"]>;
  referral_status?: InputMaybe<Scalars["referral_status"]["input"]>;
  referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  region?: InputMaybe<Scalars["String"]["input"]>;
  security_flags?: InputMaybe<Scalars["jsonb"]["input"]>;
  user_agent?: InputMaybe<Scalars["String"]["input"]>;
  utm_campaign?: InputMaybe<Scalars["String"]["input"]>;
  utm_medium?: InputMaybe<Scalars["String"]["input"]>;
  utm_source?: InputMaybe<Scalars["String"]["input"]>;
  validation_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  visitor_id?: InputMaybe<Scalars["uuid"]["input"]>;
};

/** aggregate sum on columns */
export type ReferralsSumFields = {
  __typename?: "referrals_sum_fields";
  conversion_value?: Maybe<Scalars["numeric"]["output"]>;
  validation_attempts?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "referrals" */
export enum ReferralsUpdateColumn {
  /** column name */
  BROWSER = "browser",
  /** column name */
  CLIENT_FINGERPRINT = "client_fingerprint",
  /** column name */
  CONVERSION_VALUE = "conversion_value",
  /** column name */
  CONVERTED_AT = "converted_at",
  /** column name */
  COUNTRY_CODE = "country_code",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DEVICE_TYPE = "device_type",
  /** column name */
  ID = "id",
  /** column name */
  IP_ADDRESS = "ip_address",
  /** column name */
  IS_SUSPICIOUS = "is_suspicious",
  /** column name */
  LANDING_PAGE = "landing_page",
  /** column name */
  LAST_FAILED_ATTEMPT = "last_failed_attempt",
  /** column name */
  REFERRAL_STATUS = "referral_status",
  /** column name */
  REFERRER_CODE = "referrer_code",
  /** column name */
  REGION = "region",
  /** column name */
  SECURITY_FLAGS = "security_flags",
  /** column name */
  USER_AGENT = "user_agent",
  /** column name */
  UTM_CAMPAIGN = "utm_campaign",
  /** column name */
  UTM_MEDIUM = "utm_medium",
  /** column name */
  UTM_SOURCE = "utm_source",
  /** column name */
  VALIDATION_ATTEMPTS = "validation_attempts",
  /** column name */
  VISITOR_ID = "visitor_id",
}

export type ReferralsUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<ReferralsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<ReferralsDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<ReferralsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<ReferralsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<ReferralsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<ReferralsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<ReferralsSetInput>;
  /** filter the rows which have to be updated */
  where: ReferralsBoolExp;
};

/** aggregate var_pop on columns */
export type ReferralsVarPopFields = {
  __typename?: "referrals_var_pop_fields";
  conversion_value?: Maybe<Scalars["Float"]["output"]>;
  validation_attempts?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type ReferralsVarSampFields = {
  __typename?: "referrals_var_samp_fields";
  conversion_value?: Maybe<Scalars["Float"]["output"]>;
  validation_attempts?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type ReferralsVarianceFields = {
  __typename?: "referrals_variance_fields";
  conversion_value?: Maybe<Scalars["Float"]["output"]>;
  validation_attempts?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "referrer_blocks" */
export type ReferrerBlocks = {
  __typename?: "referrer_blocks";
  blocked_at?: Maybe<Scalars["timestamptz"]["output"]>;
  blocked_by: Scalars["String"]["output"];
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id: Scalars["uuid"]["output"];
  is_permanent?: Maybe<Scalars["Boolean"]["output"]>;
  reason?: Maybe<Scalars["String"]["output"]>;
  referrer_code: Scalars["String"]["output"];
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregated selection of "referrer_blocks" */
export type ReferrerBlocksAggregate = {
  __typename?: "referrer_blocks_aggregate";
  aggregate?: Maybe<ReferrerBlocksAggregateFields>;
  nodes: Array<ReferrerBlocks>;
};

/** aggregate fields of "referrer_blocks" */
export type ReferrerBlocksAggregateFields = {
  __typename?: "referrer_blocks_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<ReferrerBlocksMaxFields>;
  min?: Maybe<ReferrerBlocksMinFields>;
};

/** aggregate fields of "referrer_blocks" */
export type ReferrerBlocksAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ReferrerBlocksSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** Boolean expression to filter rows from the table "referrer_blocks". All fields are combined with a logical 'AND'. */
export type ReferrerBlocksBoolExp = {
  _and?: InputMaybe<Array<ReferrerBlocksBoolExp>>;
  _not?: InputMaybe<ReferrerBlocksBoolExp>;
  _or?: InputMaybe<Array<ReferrerBlocksBoolExp>>;
  blocked_at?: InputMaybe<TimestamptzComparisonExp>;
  blocked_by?: InputMaybe<StringComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  is_permanent?: InputMaybe<BooleanComparisonExp>;
  reason?: InputMaybe<StringComparisonExp>;
  referrer_code?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
};

/** unique or primary key constraints on table "referrer_blocks" */
export enum ReferrerBlocksConstraint {
  /** unique or primary key constraint on columns "referrer_code" */
  IDX_REFERRER_BLOCKS_CODE = "idx_referrer_blocks_code",
  /** unique or primary key constraint on columns "id" */
  REFERRER_BLOCKS_PKEY = "referrer_blocks_pkey",
}

/** input type for inserting data into table "referrer_blocks" */
export type ReferrerBlocksInsertInput = {
  blocked_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  blocked_by?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_permanent?: InputMaybe<Scalars["Boolean"]["input"]>;
  reason?: InputMaybe<Scalars["String"]["input"]>;
  referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate max on columns */
export type ReferrerBlocksMaxFields = {
  __typename?: "referrer_blocks_max_fields";
  blocked_at?: Maybe<Scalars["timestamptz"]["output"]>;
  blocked_by?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  reason?: Maybe<Scalars["String"]["output"]>;
  referrer_code?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregate min on columns */
export type ReferrerBlocksMinFields = {
  __typename?: "referrer_blocks_min_fields";
  blocked_at?: Maybe<Scalars["timestamptz"]["output"]>;
  blocked_by?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  reason?: Maybe<Scalars["String"]["output"]>;
  referrer_code?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** response of any mutation on the table "referrer_blocks" */
export type ReferrerBlocksMutationResponse = {
  __typename?: "referrer_blocks_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<ReferrerBlocks>;
};

/** on_conflict condition type for table "referrer_blocks" */
export type ReferrerBlocksOnConflict = {
  constraint: ReferrerBlocksConstraint;
  update_columns?: Array<ReferrerBlocksUpdateColumn>;
  where?: InputMaybe<ReferrerBlocksBoolExp>;
};

/** Ordering options when selecting data from "referrer_blocks". */
export type ReferrerBlocksOrderBy = {
  blocked_at?: InputMaybe<OrderBy>;
  blocked_by?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  is_permanent?: InputMaybe<OrderBy>;
  reason?: InputMaybe<OrderBy>;
  referrer_code?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: referrer_blocks */
export type ReferrerBlocksPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "referrer_blocks" */
export enum ReferrerBlocksSelectColumn {
  /** column name */
  BLOCKED_AT = "blocked_at",
  /** column name */
  BLOCKED_BY = "blocked_by",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  IS_PERMANENT = "is_permanent",
  /** column name */
  REASON = "reason",
  /** column name */
  REFERRER_CODE = "referrer_code",
  /** column name */
  UPDATED_AT = "updated_at",
}

/** input type for updating data in table "referrer_blocks" */
export type ReferrerBlocksSetInput = {
  blocked_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  blocked_by?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_permanent?: InputMaybe<Scalars["Boolean"]["input"]>;
  reason?: InputMaybe<Scalars["String"]["input"]>;
  referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** Streaming cursor of the table "referrer_blocks" */
export type ReferrerBlocksStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ReferrerBlocksStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ReferrerBlocksStreamCursorValueInput = {
  blocked_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  blocked_by?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_permanent?: InputMaybe<Scalars["Boolean"]["input"]>;
  reason?: InputMaybe<Scalars["String"]["input"]>;
  referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** update columns of table "referrer_blocks" */
export enum ReferrerBlocksUpdateColumn {
  /** column name */
  BLOCKED_AT = "blocked_at",
  /** column name */
  BLOCKED_BY = "blocked_by",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  IS_PERMANENT = "is_permanent",
  /** column name */
  REASON = "reason",
  /** column name */
  REFERRER_CODE = "referrer_code",
  /** column name */
  UPDATED_AT = "updated_at",
}

export type ReferrerBlocksUpdates = {
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<ReferrerBlocksSetInput>;
  /** filter the rows which have to be updated */
  where: ReferrerBlocksBoolExp;
};

/** columns and relationships of "referrer_risk_metrics" */
export type ReferrerRiskMetrics = {
  __typename?: "referrer_risk_metrics";
  active_days?: Maybe<Scalars["bigint"]["output"]>;
  high_attempt_instances?: Maybe<Scalars["bigint"]["output"]>;
  max_validation_attempts?: Maybe<Scalars["Int"]["output"]>;
  referrer_code?: Maybe<Scalars["String"]["output"]>;
  suspicious_count?: Maybe<Scalars["bigint"]["output"]>;
  suspicious_percentage?: Maybe<Scalars["numeric"]["output"]>;
  total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  unique_ips?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregated selection of "referrer_risk_metrics" */
export type ReferrerRiskMetricsAggregate = {
  __typename?: "referrer_risk_metrics_aggregate";
  aggregate?: Maybe<ReferrerRiskMetricsAggregateFields>;
  nodes: Array<ReferrerRiskMetrics>;
};

/** aggregate fields of "referrer_risk_metrics" */
export type ReferrerRiskMetricsAggregateFields = {
  __typename?: "referrer_risk_metrics_aggregate_fields";
  avg?: Maybe<ReferrerRiskMetricsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ReferrerRiskMetricsMaxFields>;
  min?: Maybe<ReferrerRiskMetricsMinFields>;
  stddev?: Maybe<ReferrerRiskMetricsStddevFields>;
  stddev_pop?: Maybe<ReferrerRiskMetricsStddevPopFields>;
  stddev_samp?: Maybe<ReferrerRiskMetricsStddevSampFields>;
  sum?: Maybe<ReferrerRiskMetricsSumFields>;
  var_pop?: Maybe<ReferrerRiskMetricsVarPopFields>;
  var_samp?: Maybe<ReferrerRiskMetricsVarSampFields>;
  variance?: Maybe<ReferrerRiskMetricsVarianceFields>;
};

/** aggregate fields of "referrer_risk_metrics" */
export type ReferrerRiskMetricsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ReferrerRiskMetricsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type ReferrerRiskMetricsAvgFields = {
  __typename?: "referrer_risk_metrics_avg_fields";
  active_days?: Maybe<Scalars["Float"]["output"]>;
  high_attempt_instances?: Maybe<Scalars["Float"]["output"]>;
  max_validation_attempts?: Maybe<Scalars["Float"]["output"]>;
  suspicious_count?: Maybe<Scalars["Float"]["output"]>;
  suspicious_percentage?: Maybe<Scalars["Float"]["output"]>;
  total_referrals?: Maybe<Scalars["Float"]["output"]>;
  unique_ips?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "referrer_risk_metrics". All fields are combined with a logical 'AND'. */
export type ReferrerRiskMetricsBoolExp = {
  _and?: InputMaybe<Array<ReferrerRiskMetricsBoolExp>>;
  _not?: InputMaybe<ReferrerRiskMetricsBoolExp>;
  _or?: InputMaybe<Array<ReferrerRiskMetricsBoolExp>>;
  active_days?: InputMaybe<BigintComparisonExp>;
  high_attempt_instances?: InputMaybe<BigintComparisonExp>;
  max_validation_attempts?: InputMaybe<IntComparisonExp>;
  referrer_code?: InputMaybe<StringComparisonExp>;
  suspicious_count?: InputMaybe<BigintComparisonExp>;
  suspicious_percentage?: InputMaybe<NumericComparisonExp>;
  total_referrals?: InputMaybe<BigintComparisonExp>;
  unique_ips?: InputMaybe<BigintComparisonExp>;
};

/** aggregate max on columns */
export type ReferrerRiskMetricsMaxFields = {
  __typename?: "referrer_risk_metrics_max_fields";
  active_days?: Maybe<Scalars["bigint"]["output"]>;
  high_attempt_instances?: Maybe<Scalars["bigint"]["output"]>;
  max_validation_attempts?: Maybe<Scalars["Int"]["output"]>;
  referrer_code?: Maybe<Scalars["String"]["output"]>;
  suspicious_count?: Maybe<Scalars["bigint"]["output"]>;
  suspicious_percentage?: Maybe<Scalars["numeric"]["output"]>;
  total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  unique_ips?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate min on columns */
export type ReferrerRiskMetricsMinFields = {
  __typename?: "referrer_risk_metrics_min_fields";
  active_days?: Maybe<Scalars["bigint"]["output"]>;
  high_attempt_instances?: Maybe<Scalars["bigint"]["output"]>;
  max_validation_attempts?: Maybe<Scalars["Int"]["output"]>;
  referrer_code?: Maybe<Scalars["String"]["output"]>;
  suspicious_count?: Maybe<Scalars["bigint"]["output"]>;
  suspicious_percentage?: Maybe<Scalars["numeric"]["output"]>;
  total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  unique_ips?: Maybe<Scalars["bigint"]["output"]>;
};

/** Ordering options when selecting data from "referrer_risk_metrics". */
export type ReferrerRiskMetricsOrderBy = {
  active_days?: InputMaybe<OrderBy>;
  high_attempt_instances?: InputMaybe<OrderBy>;
  max_validation_attempts?: InputMaybe<OrderBy>;
  referrer_code?: InputMaybe<OrderBy>;
  suspicious_count?: InputMaybe<OrderBy>;
  suspicious_percentage?: InputMaybe<OrderBy>;
  total_referrals?: InputMaybe<OrderBy>;
  unique_ips?: InputMaybe<OrderBy>;
};

/** select columns of table "referrer_risk_metrics" */
export enum ReferrerRiskMetricsSelectColumn {
  /** column name */
  ACTIVE_DAYS = "active_days",
  /** column name */
  HIGH_ATTEMPT_INSTANCES = "high_attempt_instances",
  /** column name */
  MAX_VALIDATION_ATTEMPTS = "max_validation_attempts",
  /** column name */
  REFERRER_CODE = "referrer_code",
  /** column name */
  SUSPICIOUS_COUNT = "suspicious_count",
  /** column name */
  SUSPICIOUS_PERCENTAGE = "suspicious_percentage",
  /** column name */
  TOTAL_REFERRALS = "total_referrals",
  /** column name */
  UNIQUE_IPS = "unique_ips",
}

/** aggregate stddev on columns */
export type ReferrerRiskMetricsStddevFields = {
  __typename?: "referrer_risk_metrics_stddev_fields";
  active_days?: Maybe<Scalars["Float"]["output"]>;
  high_attempt_instances?: Maybe<Scalars["Float"]["output"]>;
  max_validation_attempts?: Maybe<Scalars["Float"]["output"]>;
  suspicious_count?: Maybe<Scalars["Float"]["output"]>;
  suspicious_percentage?: Maybe<Scalars["Float"]["output"]>;
  total_referrals?: Maybe<Scalars["Float"]["output"]>;
  unique_ips?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type ReferrerRiskMetricsStddevPopFields = {
  __typename?: "referrer_risk_metrics_stddev_pop_fields";
  active_days?: Maybe<Scalars["Float"]["output"]>;
  high_attempt_instances?: Maybe<Scalars["Float"]["output"]>;
  max_validation_attempts?: Maybe<Scalars["Float"]["output"]>;
  suspicious_count?: Maybe<Scalars["Float"]["output"]>;
  suspicious_percentage?: Maybe<Scalars["Float"]["output"]>;
  total_referrals?: Maybe<Scalars["Float"]["output"]>;
  unique_ips?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type ReferrerRiskMetricsStddevSampFields = {
  __typename?: "referrer_risk_metrics_stddev_samp_fields";
  active_days?: Maybe<Scalars["Float"]["output"]>;
  high_attempt_instances?: Maybe<Scalars["Float"]["output"]>;
  max_validation_attempts?: Maybe<Scalars["Float"]["output"]>;
  suspicious_count?: Maybe<Scalars["Float"]["output"]>;
  suspicious_percentage?: Maybe<Scalars["Float"]["output"]>;
  total_referrals?: Maybe<Scalars["Float"]["output"]>;
  unique_ips?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "referrer_risk_metrics" */
export type ReferrerRiskMetricsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ReferrerRiskMetricsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ReferrerRiskMetricsStreamCursorValueInput = {
  active_days?: InputMaybe<Scalars["bigint"]["input"]>;
  high_attempt_instances?: InputMaybe<Scalars["bigint"]["input"]>;
  max_validation_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  suspicious_count?: InputMaybe<Scalars["bigint"]["input"]>;
  suspicious_percentage?: InputMaybe<Scalars["numeric"]["input"]>;
  total_referrals?: InputMaybe<Scalars["bigint"]["input"]>;
  unique_ips?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** aggregate sum on columns */
export type ReferrerRiskMetricsSumFields = {
  __typename?: "referrer_risk_metrics_sum_fields";
  active_days?: Maybe<Scalars["bigint"]["output"]>;
  high_attempt_instances?: Maybe<Scalars["bigint"]["output"]>;
  max_validation_attempts?: Maybe<Scalars["Int"]["output"]>;
  suspicious_count?: Maybe<Scalars["bigint"]["output"]>;
  suspicious_percentage?: Maybe<Scalars["numeric"]["output"]>;
  total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  unique_ips?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate var_pop on columns */
export type ReferrerRiskMetricsVarPopFields = {
  __typename?: "referrer_risk_metrics_var_pop_fields";
  active_days?: Maybe<Scalars["Float"]["output"]>;
  high_attempt_instances?: Maybe<Scalars["Float"]["output"]>;
  max_validation_attempts?: Maybe<Scalars["Float"]["output"]>;
  suspicious_count?: Maybe<Scalars["Float"]["output"]>;
  suspicious_percentage?: Maybe<Scalars["Float"]["output"]>;
  total_referrals?: Maybe<Scalars["Float"]["output"]>;
  unique_ips?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type ReferrerRiskMetricsVarSampFields = {
  __typename?: "referrer_risk_metrics_var_samp_fields";
  active_days?: Maybe<Scalars["Float"]["output"]>;
  high_attempt_instances?: Maybe<Scalars["Float"]["output"]>;
  max_validation_attempts?: Maybe<Scalars["Float"]["output"]>;
  suspicious_count?: Maybe<Scalars["Float"]["output"]>;
  suspicious_percentage?: Maybe<Scalars["Float"]["output"]>;
  total_referrals?: Maybe<Scalars["Float"]["output"]>;
  unique_ips?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type ReferrerRiskMetricsVarianceFields = {
  __typename?: "referrer_risk_metrics_variance_fields";
  active_days?: Maybe<Scalars["Float"]["output"]>;
  high_attempt_instances?: Maybe<Scalars["Float"]["output"]>;
  max_validation_attempts?: Maybe<Scalars["Float"]["output"]>;
  suspicious_count?: Maybe<Scalars["Float"]["output"]>;
  suspicious_percentage?: Maybe<Scalars["Float"]["output"]>;
  total_referrals?: Maybe<Scalars["Float"]["output"]>;
  unique_ips?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "research" */
export type Research = {
  __typename?: "research";
  abstract?: Maybe<Scalars["String"]["output"]>;
  abstract_url: Scalars["String"]["output"];
  affiliations?: Maybe<Scalars["jsonb"]["output"]>;
  authors?: Maybe<Scalars["jsonb"]["output"]>;
  category?: Maybe<Scalars["String"]["output"]>;
  comments?: Maybe<Scalars["String"]["output"]>;
  /** An object relationship */
  content: Contents;
  content_status: Scalars["content_status"]["output"];
  created_at: Scalars["timestamptz"]["output"];
  doi_url?: Maybe<Scalars["String"]["output"]>;
  figure_count?: Maybe<Scalars["smallint"]["output"]>;
  has_embedding?: Maybe<Scalars["Boolean"]["output"]>;
  id: Scalars["uuid"]["output"];
  is_flagged: Scalars["Boolean"]["output"];
  keywords?: Maybe<Scalars["String"]["output"]>;
  month?: Maybe<Scalars["String"]["output"]>;
  page_count?: Maybe<Scalars["smallint"]["output"]>;
  pdf_url?: Maybe<Scalars["String"]["output"]>;
  published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  published_in?: Maybe<Scalars["String"]["output"]>;
  /** An object relationship */
  research_embedding?: Maybe<ResearchEmbeddings>;
  summary?: Maybe<Scalars["String"]["output"]>;
  table_count?: Maybe<Scalars["smallint"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  version?: Maybe<Scalars["smallint"]["output"]>;
  year?: Maybe<Scalars["String"]["output"]>;
};

/** columns and relationships of "research" */
export type ResearchAffiliationsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "research" */
export type ResearchAuthorsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "research" */
export type ResearchAggregate = {
  __typename?: "research_aggregate";
  aggregate?: Maybe<ResearchAggregateFields>;
  nodes: Array<Research>;
};

/** aggregate fields of "research" */
export type ResearchAggregateFields = {
  __typename?: "research_aggregate_fields";
  avg?: Maybe<ResearchAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ResearchMaxFields>;
  min?: Maybe<ResearchMinFields>;
  stddev?: Maybe<ResearchStddevFields>;
  stddev_pop?: Maybe<ResearchStddevPopFields>;
  stddev_samp?: Maybe<ResearchStddevSampFields>;
  sum?: Maybe<ResearchSumFields>;
  var_pop?: Maybe<ResearchVarPopFields>;
  var_samp?: Maybe<ResearchVarSampFields>;
  variance?: Maybe<ResearchVarianceFields>;
};

/** aggregate fields of "research" */
export type ResearchAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ResearchSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type ResearchAppendInput = {
  affiliations?: InputMaybe<Scalars["jsonb"]["input"]>;
  authors?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** aggregate avg on columns */
export type ResearchAvgFields = {
  __typename?: "research_avg_fields";
  figure_count?: Maybe<Scalars["Float"]["output"]>;
  page_count?: Maybe<Scalars["Float"]["output"]>;
  table_count?: Maybe<Scalars["Float"]["output"]>;
  version?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "research". All fields are combined with a logical 'AND'. */
export type ResearchBoolExp = {
  _and?: InputMaybe<Array<ResearchBoolExp>>;
  _not?: InputMaybe<ResearchBoolExp>;
  _or?: InputMaybe<Array<ResearchBoolExp>>;
  abstract?: InputMaybe<StringComparisonExp>;
  abstract_url?: InputMaybe<StringComparisonExp>;
  affiliations?: InputMaybe<JsonbComparisonExp>;
  authors?: InputMaybe<JsonbComparisonExp>;
  category?: InputMaybe<StringComparisonExp>;
  comments?: InputMaybe<StringComparisonExp>;
  content?: InputMaybe<ContentsBoolExp>;
  content_status?: InputMaybe<ContentStatusComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  doi_url?: InputMaybe<StringComparisonExp>;
  figure_count?: InputMaybe<SmallintComparisonExp>;
  has_embedding?: InputMaybe<BooleanComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  is_flagged?: InputMaybe<BooleanComparisonExp>;
  keywords?: InputMaybe<StringComparisonExp>;
  month?: InputMaybe<StringComparisonExp>;
  page_count?: InputMaybe<SmallintComparisonExp>;
  pdf_url?: InputMaybe<StringComparisonExp>;
  published_at?: InputMaybe<TimestamptzComparisonExp>;
  published_in?: InputMaybe<StringComparisonExp>;
  research_embedding?: InputMaybe<ResearchEmbeddingsBoolExp>;
  summary?: InputMaybe<StringComparisonExp>;
  table_count?: InputMaybe<SmallintComparisonExp>;
  title?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  version?: InputMaybe<SmallintComparisonExp>;
  year?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "research" */
export enum ResearchConstraint {
  /** unique or primary key constraint on columns "pdf_url" */
  RESEARCH_PDF_URL_KEY = "research_pdf_url_key",
  /** unique or primary key constraint on columns "id" */
  RESEARCH_PKEY = "research_pkey",
  /** unique or primary key constraint on columns "abstract_url" */
  RESEARCH_URL_KEY = "research_url_key",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type ResearchDeleteAtPathInput = {
  affiliations?: InputMaybe<Array<Scalars["String"]["input"]>>;
  authors?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type ResearchDeleteElemInput = {
  affiliations?: InputMaybe<Scalars["Int"]["input"]>;
  authors?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type ResearchDeleteKeyInput = {
  affiliations?: InputMaybe<Scalars["String"]["input"]>;
  authors?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "research_embeddings" */
export type ResearchEmbeddings = {
  __typename?: "research_embeddings";
  chunk: Scalars["String"]["output"];
  created_at?: Maybe<Scalars["timestamp"]["output"]>;
  embedding?: Maybe<Scalars["vector"]["output"]>;
  /** An object relationship */
  embedding_review?: Maybe<EmbeddingReviews>;
  embedding_review_id?: Maybe<Scalars["bigint"]["output"]>;
  id: Scalars["Int"]["output"];
  is_flagged?: Maybe<Scalars["Boolean"]["output"]>;
  /** An object relationship */
  research: Research;
  research_id: Scalars["uuid"]["output"];
  updated_at: Scalars["timestamptz"]["output"];
  url?: Maybe<Scalars["String"]["output"]>;
};

/** aggregated selection of "research_embeddings" */
export type ResearchEmbeddingsAggregate = {
  __typename?: "research_embeddings_aggregate";
  aggregate?: Maybe<ResearchEmbeddingsAggregateFields>;
  nodes: Array<ResearchEmbeddings>;
};

export type ResearchEmbeddingsAggregateBoolExp = {
  bool_and?: InputMaybe<ResearchEmbeddingsAggregateBoolExpBoolAnd>;
  bool_or?: InputMaybe<ResearchEmbeddingsAggregateBoolExpBoolOr>;
  count?: InputMaybe<ResearchEmbeddingsAggregateBoolExpCount>;
};

export type ResearchEmbeddingsAggregateBoolExpBoolAnd = {
  arguments: ResearchEmbeddingsSelectColumnResearchEmbeddingsAggregateBoolExpBoolAndArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ResearchEmbeddingsBoolExp>;
  predicate: BooleanComparisonExp;
};

export type ResearchEmbeddingsAggregateBoolExpBoolOr = {
  arguments: ResearchEmbeddingsSelectColumnResearchEmbeddingsAggregateBoolExpBoolOrArgumentsColumns;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ResearchEmbeddingsBoolExp>;
  predicate: BooleanComparisonExp;
};

export type ResearchEmbeddingsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<ResearchEmbeddingsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ResearchEmbeddingsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "research_embeddings" */
export type ResearchEmbeddingsAggregateFields = {
  __typename?: "research_embeddings_aggregate_fields";
  avg?: Maybe<ResearchEmbeddingsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ResearchEmbeddingsMaxFields>;
  min?: Maybe<ResearchEmbeddingsMinFields>;
  stddev?: Maybe<ResearchEmbeddingsStddevFields>;
  stddev_pop?: Maybe<ResearchEmbeddingsStddevPopFields>;
  stddev_samp?: Maybe<ResearchEmbeddingsStddevSampFields>;
  sum?: Maybe<ResearchEmbeddingsSumFields>;
  var_pop?: Maybe<ResearchEmbeddingsVarPopFields>;
  var_samp?: Maybe<ResearchEmbeddingsVarSampFields>;
  variance?: Maybe<ResearchEmbeddingsVarianceFields>;
};

/** aggregate fields of "research_embeddings" */
export type ResearchEmbeddingsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ResearchEmbeddingsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "research_embeddings" */
export type ResearchEmbeddingsAggregateOrderBy = {
  avg?: InputMaybe<ResearchEmbeddingsAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<ResearchEmbeddingsMaxOrderBy>;
  min?: InputMaybe<ResearchEmbeddingsMinOrderBy>;
  stddev?: InputMaybe<ResearchEmbeddingsStddevOrderBy>;
  stddev_pop?: InputMaybe<ResearchEmbeddingsStddevPopOrderBy>;
  stddev_samp?: InputMaybe<ResearchEmbeddingsStddevSampOrderBy>;
  sum?: InputMaybe<ResearchEmbeddingsSumOrderBy>;
  var_pop?: InputMaybe<ResearchEmbeddingsVarPopOrderBy>;
  var_samp?: InputMaybe<ResearchEmbeddingsVarSampOrderBy>;
  variance?: InputMaybe<ResearchEmbeddingsVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "research_embeddings" */
export type ResearchEmbeddingsArrRelInsertInput = {
  data: Array<ResearchEmbeddingsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<ResearchEmbeddingsOnConflict>;
};

/** aggregate avg on columns */
export type ResearchEmbeddingsAvgFields = {
  __typename?: "research_embeddings_avg_fields";
  embedding_review_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "research_embeddings" */
export type ResearchEmbeddingsAvgOrderBy = {
  embedding_review_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "research_embeddings". All fields are combined with a logical 'AND'. */
export type ResearchEmbeddingsBoolExp = {
  _and?: InputMaybe<Array<ResearchEmbeddingsBoolExp>>;
  _not?: InputMaybe<ResearchEmbeddingsBoolExp>;
  _or?: InputMaybe<Array<ResearchEmbeddingsBoolExp>>;
  chunk?: InputMaybe<StringComparisonExp>;
  created_at?: InputMaybe<TimestampComparisonExp>;
  embedding?: InputMaybe<VectorComparisonExp>;
  embedding_review?: InputMaybe<EmbeddingReviewsBoolExp>;
  embedding_review_id?: InputMaybe<BigintComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  is_flagged?: InputMaybe<BooleanComparisonExp>;
  research?: InputMaybe<ResearchBoolExp>;
  research_id?: InputMaybe<UuidComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  url?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "research_embeddings" */
export enum ResearchEmbeddingsConstraint {
  /** unique or primary key constraint on columns "id" */
  RESEARCH_EMBEDDINGS_ID_KEY = "research_embeddings_id_key",
  /** unique or primary key constraint on columns "id" */
  RESEARCH_EMBEDDINGS_PKEY = "research_embeddings_pkey",
  /** unique or primary key constraint on columns "research_id" */
  RESEARCH_EMBEDDINGS_RESEARCH_ID_KEY = "research_embeddings_research_id_key",
}

/** input type for incrementing numeric columns in table "research_embeddings" */
export type ResearchEmbeddingsIncInput = {
  embedding_review_id?: InputMaybe<Scalars["bigint"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "research_embeddings" */
export type ResearchEmbeddingsInsertInput = {
  chunk?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  embedding?: InputMaybe<Scalars["vector"]["input"]>;
  embedding_review?: InputMaybe<EmbeddingReviewsObjRelInsertInput>;
  embedding_review_id?: InputMaybe<Scalars["bigint"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  is_flagged?: InputMaybe<Scalars["Boolean"]["input"]>;
  research?: InputMaybe<ResearchObjRelInsertInput>;
  research_id?: InputMaybe<Scalars["uuid"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type ResearchEmbeddingsMaxFields = {
  __typename?: "research_embeddings_max_fields";
  chunk?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamp"]["output"]>;
  embedding_review_id?: Maybe<Scalars["bigint"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  research_id?: Maybe<Scalars["uuid"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** order by max() on columns of table "research_embeddings" */
export type ResearchEmbeddingsMaxOrderBy = {
  chunk?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  embedding_review_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  research_id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type ResearchEmbeddingsMinFields = {
  __typename?: "research_embeddings_min_fields";
  chunk?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamp"]["output"]>;
  embedding_review_id?: Maybe<Scalars["bigint"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  research_id?: Maybe<Scalars["uuid"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  url?: Maybe<Scalars["String"]["output"]>;
};

/** order by min() on columns of table "research_embeddings" */
export type ResearchEmbeddingsMinOrderBy = {
  chunk?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  embedding_review_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  research_id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "research_embeddings" */
export type ResearchEmbeddingsMutationResponse = {
  __typename?: "research_embeddings_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<ResearchEmbeddings>;
};

/** input type for inserting object relation for remote table "research_embeddings" */
export type ResearchEmbeddingsObjRelInsertInput = {
  data: ResearchEmbeddingsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<ResearchEmbeddingsOnConflict>;
};

/** on_conflict condition type for table "research_embeddings" */
export type ResearchEmbeddingsOnConflict = {
  constraint: ResearchEmbeddingsConstraint;
  update_columns?: Array<ResearchEmbeddingsUpdateColumn>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

/** Ordering options when selecting data from "research_embeddings". */
export type ResearchEmbeddingsOrderBy = {
  chunk?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  embedding?: InputMaybe<OrderBy>;
  embedding_review?: InputMaybe<EmbeddingReviewsOrderBy>;
  embedding_review_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  is_flagged?: InputMaybe<OrderBy>;
  research?: InputMaybe<ResearchOrderBy>;
  research_id?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  url?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: research_embeddings */
export type ResearchEmbeddingsPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "research_embeddings" */
export enum ResearchEmbeddingsSelectColumn {
  /** column name */
  CHUNK = "chunk",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  EMBEDDING = "embedding",
  /** column name */
  EMBEDDING_REVIEW_ID = "embedding_review_id",
  /** column name */
  ID = "id",
  /** column name */
  IS_FLAGGED = "is_flagged",
  /** column name */
  RESEARCH_ID = "research_id",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
}

/** select "research_embeddings_aggregate_bool_exp_bool_and_arguments_columns" columns of table "research_embeddings" */
export enum ResearchEmbeddingsSelectColumnResearchEmbeddingsAggregateBoolExpBoolAndArgumentsColumns {
  /** column name */
  IS_FLAGGED = "is_flagged",
}

/** select "research_embeddings_aggregate_bool_exp_bool_or_arguments_columns" columns of table "research_embeddings" */
export enum ResearchEmbeddingsSelectColumnResearchEmbeddingsAggregateBoolExpBoolOrArgumentsColumns {
  /** column name */
  IS_FLAGGED = "is_flagged",
}

/** input type for updating data in table "research_embeddings" */
export type ResearchEmbeddingsSetInput = {
  chunk?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  embedding?: InputMaybe<Scalars["vector"]["input"]>;
  embedding_review_id?: InputMaybe<Scalars["bigint"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  is_flagged?: InputMaybe<Scalars["Boolean"]["input"]>;
  research_id?: InputMaybe<Scalars["uuid"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type ResearchEmbeddingsStddevFields = {
  __typename?: "research_embeddings_stddev_fields";
  embedding_review_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "research_embeddings" */
export type ResearchEmbeddingsStddevOrderBy = {
  embedding_review_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type ResearchEmbeddingsStddevPopFields = {
  __typename?: "research_embeddings_stddev_pop_fields";
  embedding_review_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "research_embeddings" */
export type ResearchEmbeddingsStddevPopOrderBy = {
  embedding_review_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type ResearchEmbeddingsStddevSampFields = {
  __typename?: "research_embeddings_stddev_samp_fields";
  embedding_review_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "research_embeddings" */
export type ResearchEmbeddingsStddevSampOrderBy = {
  embedding_review_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "research_embeddings" */
export type ResearchEmbeddingsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ResearchEmbeddingsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ResearchEmbeddingsStreamCursorValueInput = {
  chunk?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  embedding?: InputMaybe<Scalars["vector"]["input"]>;
  embedding_review_id?: InputMaybe<Scalars["bigint"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  is_flagged?: InputMaybe<Scalars["Boolean"]["input"]>;
  research_id?: InputMaybe<Scalars["uuid"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type ResearchEmbeddingsSumFields = {
  __typename?: "research_embeddings_sum_fields";
  embedding_review_id?: Maybe<Scalars["bigint"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "research_embeddings" */
export type ResearchEmbeddingsSumOrderBy = {
  embedding_review_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** update columns of table "research_embeddings" */
export enum ResearchEmbeddingsUpdateColumn {
  /** column name */
  CHUNK = "chunk",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  EMBEDDING = "embedding",
  /** column name */
  EMBEDDING_REVIEW_ID = "embedding_review_id",
  /** column name */
  ID = "id",
  /** column name */
  IS_FLAGGED = "is_flagged",
  /** column name */
  RESEARCH_ID = "research_id",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  URL = "url",
}

export type ResearchEmbeddingsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<ResearchEmbeddingsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<ResearchEmbeddingsSetInput>;
  /** filter the rows which have to be updated */
  where: ResearchEmbeddingsBoolExp;
};

/** aggregate var_pop on columns */
export type ResearchEmbeddingsVarPopFields = {
  __typename?: "research_embeddings_var_pop_fields";
  embedding_review_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "research_embeddings" */
export type ResearchEmbeddingsVarPopOrderBy = {
  embedding_review_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type ResearchEmbeddingsVarSampFields = {
  __typename?: "research_embeddings_var_samp_fields";
  embedding_review_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "research_embeddings" */
export type ResearchEmbeddingsVarSampOrderBy = {
  embedding_review_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type ResearchEmbeddingsVarianceFields = {
  __typename?: "research_embeddings_variance_fields";
  embedding_review_id?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "research_embeddings" */
export type ResearchEmbeddingsVarianceOrderBy = {
  embedding_review_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
};

/** input type for incrementing numeric columns in table "research" */
export type ResearchIncInput = {
  figure_count?: InputMaybe<Scalars["smallint"]["input"]>;
  page_count?: InputMaybe<Scalars["smallint"]["input"]>;
  table_count?: InputMaybe<Scalars["smallint"]["input"]>;
  version?: InputMaybe<Scalars["smallint"]["input"]>;
};

/** input type for inserting data into table "research" */
export type ResearchInsertInput = {
  abstract?: InputMaybe<Scalars["String"]["input"]>;
  abstract_url?: InputMaybe<Scalars["String"]["input"]>;
  affiliations?: InputMaybe<Scalars["jsonb"]["input"]>;
  authors?: InputMaybe<Scalars["jsonb"]["input"]>;
  category?: InputMaybe<Scalars["String"]["input"]>;
  comments?: InputMaybe<Scalars["String"]["input"]>;
  content?: InputMaybe<ContentsObjRelInsertInput>;
  content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  doi_url?: InputMaybe<Scalars["String"]["input"]>;
  figure_count?: InputMaybe<Scalars["smallint"]["input"]>;
  has_embedding?: InputMaybe<Scalars["Boolean"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_flagged?: InputMaybe<Scalars["Boolean"]["input"]>;
  keywords?: InputMaybe<Scalars["String"]["input"]>;
  month?: InputMaybe<Scalars["String"]["input"]>;
  page_count?: InputMaybe<Scalars["smallint"]["input"]>;
  pdf_url?: InputMaybe<Scalars["String"]["input"]>;
  published_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  published_in?: InputMaybe<Scalars["String"]["input"]>;
  research_embedding?: InputMaybe<ResearchEmbeddingsObjRelInsertInput>;
  summary?: InputMaybe<Scalars["String"]["input"]>;
  table_count?: InputMaybe<Scalars["smallint"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  version?: InputMaybe<Scalars["smallint"]["input"]>;
  year?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type ResearchMaxFields = {
  __typename?: "research_max_fields";
  abstract?: Maybe<Scalars["String"]["output"]>;
  abstract_url?: Maybe<Scalars["String"]["output"]>;
  category?: Maybe<Scalars["String"]["output"]>;
  comments?: Maybe<Scalars["String"]["output"]>;
  content_status?: Maybe<Scalars["content_status"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  doi_url?: Maybe<Scalars["String"]["output"]>;
  figure_count?: Maybe<Scalars["smallint"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  keywords?: Maybe<Scalars["String"]["output"]>;
  month?: Maybe<Scalars["String"]["output"]>;
  page_count?: Maybe<Scalars["smallint"]["output"]>;
  pdf_url?: Maybe<Scalars["String"]["output"]>;
  published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  published_in?: Maybe<Scalars["String"]["output"]>;
  summary?: Maybe<Scalars["String"]["output"]>;
  table_count?: Maybe<Scalars["smallint"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  version?: Maybe<Scalars["smallint"]["output"]>;
  year?: Maybe<Scalars["String"]["output"]>;
};

/** aggregate min on columns */
export type ResearchMinFields = {
  __typename?: "research_min_fields";
  abstract?: Maybe<Scalars["String"]["output"]>;
  abstract_url?: Maybe<Scalars["String"]["output"]>;
  category?: Maybe<Scalars["String"]["output"]>;
  comments?: Maybe<Scalars["String"]["output"]>;
  content_status?: Maybe<Scalars["content_status"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  doi_url?: Maybe<Scalars["String"]["output"]>;
  figure_count?: Maybe<Scalars["smallint"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  keywords?: Maybe<Scalars["String"]["output"]>;
  month?: Maybe<Scalars["String"]["output"]>;
  page_count?: Maybe<Scalars["smallint"]["output"]>;
  pdf_url?: Maybe<Scalars["String"]["output"]>;
  published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  published_in?: Maybe<Scalars["String"]["output"]>;
  summary?: Maybe<Scalars["String"]["output"]>;
  table_count?: Maybe<Scalars["smallint"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  version?: Maybe<Scalars["smallint"]["output"]>;
  year?: Maybe<Scalars["String"]["output"]>;
};

/** response of any mutation on the table "research" */
export type ResearchMutationResponse = {
  __typename?: "research_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Research>;
};

/** input type for inserting object relation for remote table "research" */
export type ResearchObjRelInsertInput = {
  data: ResearchInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<ResearchOnConflict>;
};

/** on_conflict condition type for table "research" */
export type ResearchOnConflict = {
  constraint: ResearchConstraint;
  update_columns?: Array<ResearchUpdateColumn>;
  where?: InputMaybe<ResearchBoolExp>;
};

/** Ordering options when selecting data from "research". */
export type ResearchOrderBy = {
  abstract?: InputMaybe<OrderBy>;
  abstract_url?: InputMaybe<OrderBy>;
  affiliations?: InputMaybe<OrderBy>;
  authors?: InputMaybe<OrderBy>;
  category?: InputMaybe<OrderBy>;
  comments?: InputMaybe<OrderBy>;
  content?: InputMaybe<ContentsOrderBy>;
  content_status?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  doi_url?: InputMaybe<OrderBy>;
  figure_count?: InputMaybe<OrderBy>;
  has_embedding?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  is_flagged?: InputMaybe<OrderBy>;
  keywords?: InputMaybe<OrderBy>;
  month?: InputMaybe<OrderBy>;
  page_count?: InputMaybe<OrderBy>;
  pdf_url?: InputMaybe<OrderBy>;
  published_at?: InputMaybe<OrderBy>;
  published_in?: InputMaybe<OrderBy>;
  research_embedding?: InputMaybe<ResearchEmbeddingsOrderBy>;
  summary?: InputMaybe<OrderBy>;
  table_count?: InputMaybe<OrderBy>;
  title?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  version?: InputMaybe<OrderBy>;
  year?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: research */
export type ResearchPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type ResearchPrependInput = {
  affiliations?: InputMaybe<Scalars["jsonb"]["input"]>;
  authors?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "research" */
export enum ResearchSelectColumn {
  /** column name */
  ABSTRACT = "abstract",
  /** column name */
  ABSTRACT_URL = "abstract_url",
  /** column name */
  AFFILIATIONS = "affiliations",
  /** column name */
  AUTHORS = "authors",
  /** column name */
  CATEGORY = "category",
  /** column name */
  COMMENTS = "comments",
  /** column name */
  CONTENT_STATUS = "content_status",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DOI_URL = "doi_url",
  /** column name */
  FIGURE_COUNT = "figure_count",
  /** column name */
  HAS_EMBEDDING = "has_embedding",
  /** column name */
  ID = "id",
  /** column name */
  IS_FLAGGED = "is_flagged",
  /** column name */
  KEYWORDS = "keywords",
  /** column name */
  MONTH = "month",
  /** column name */
  PAGE_COUNT = "page_count",
  /** column name */
  PDF_URL = "pdf_url",
  /** column name */
  PUBLISHED_AT = "published_at",
  /** column name */
  PUBLISHED_IN = "published_in",
  /** column name */
  SUMMARY = "summary",
  /** column name */
  TABLE_COUNT = "table_count",
  /** column name */
  TITLE = "title",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  VERSION = "version",
  /** column name */
  YEAR = "year",
}

/** input type for updating data in table "research" */
export type ResearchSetInput = {
  abstract?: InputMaybe<Scalars["String"]["input"]>;
  abstract_url?: InputMaybe<Scalars["String"]["input"]>;
  affiliations?: InputMaybe<Scalars["jsonb"]["input"]>;
  authors?: InputMaybe<Scalars["jsonb"]["input"]>;
  category?: InputMaybe<Scalars["String"]["input"]>;
  comments?: InputMaybe<Scalars["String"]["input"]>;
  content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  doi_url?: InputMaybe<Scalars["String"]["input"]>;
  figure_count?: InputMaybe<Scalars["smallint"]["input"]>;
  has_embedding?: InputMaybe<Scalars["Boolean"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_flagged?: InputMaybe<Scalars["Boolean"]["input"]>;
  keywords?: InputMaybe<Scalars["String"]["input"]>;
  month?: InputMaybe<Scalars["String"]["input"]>;
  page_count?: InputMaybe<Scalars["smallint"]["input"]>;
  pdf_url?: InputMaybe<Scalars["String"]["input"]>;
  published_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  published_in?: InputMaybe<Scalars["String"]["input"]>;
  summary?: InputMaybe<Scalars["String"]["input"]>;
  table_count?: InputMaybe<Scalars["smallint"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  version?: InputMaybe<Scalars["smallint"]["input"]>;
  year?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type ResearchStddevFields = {
  __typename?: "research_stddev_fields";
  figure_count?: Maybe<Scalars["Float"]["output"]>;
  page_count?: Maybe<Scalars["Float"]["output"]>;
  table_count?: Maybe<Scalars["Float"]["output"]>;
  version?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type ResearchStddevPopFields = {
  __typename?: "research_stddev_pop_fields";
  figure_count?: Maybe<Scalars["Float"]["output"]>;
  page_count?: Maybe<Scalars["Float"]["output"]>;
  table_count?: Maybe<Scalars["Float"]["output"]>;
  version?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type ResearchStddevSampFields = {
  __typename?: "research_stddev_samp_fields";
  figure_count?: Maybe<Scalars["Float"]["output"]>;
  page_count?: Maybe<Scalars["Float"]["output"]>;
  table_count?: Maybe<Scalars["Float"]["output"]>;
  version?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "research" */
export type ResearchStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ResearchStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ResearchStreamCursorValueInput = {
  abstract?: InputMaybe<Scalars["String"]["input"]>;
  abstract_url?: InputMaybe<Scalars["String"]["input"]>;
  affiliations?: InputMaybe<Scalars["jsonb"]["input"]>;
  authors?: InputMaybe<Scalars["jsonb"]["input"]>;
  category?: InputMaybe<Scalars["String"]["input"]>;
  comments?: InputMaybe<Scalars["String"]["input"]>;
  content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  doi_url?: InputMaybe<Scalars["String"]["input"]>;
  figure_count?: InputMaybe<Scalars["smallint"]["input"]>;
  has_embedding?: InputMaybe<Scalars["Boolean"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  is_flagged?: InputMaybe<Scalars["Boolean"]["input"]>;
  keywords?: InputMaybe<Scalars["String"]["input"]>;
  month?: InputMaybe<Scalars["String"]["input"]>;
  page_count?: InputMaybe<Scalars["smallint"]["input"]>;
  pdf_url?: InputMaybe<Scalars["String"]["input"]>;
  published_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  published_in?: InputMaybe<Scalars["String"]["input"]>;
  summary?: InputMaybe<Scalars["String"]["input"]>;
  table_count?: InputMaybe<Scalars["smallint"]["input"]>;
  title?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  version?: InputMaybe<Scalars["smallint"]["input"]>;
  year?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type ResearchSumFields = {
  __typename?: "research_sum_fields";
  figure_count?: Maybe<Scalars["smallint"]["output"]>;
  page_count?: Maybe<Scalars["smallint"]["output"]>;
  table_count?: Maybe<Scalars["smallint"]["output"]>;
  version?: Maybe<Scalars["smallint"]["output"]>;
};

/** update columns of table "research" */
export enum ResearchUpdateColumn {
  /** column name */
  ABSTRACT = "abstract",
  /** column name */
  ABSTRACT_URL = "abstract_url",
  /** column name */
  AFFILIATIONS = "affiliations",
  /** column name */
  AUTHORS = "authors",
  /** column name */
  CATEGORY = "category",
  /** column name */
  COMMENTS = "comments",
  /** column name */
  CONTENT_STATUS = "content_status",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DOI_URL = "doi_url",
  /** column name */
  FIGURE_COUNT = "figure_count",
  /** column name */
  HAS_EMBEDDING = "has_embedding",
  /** column name */
  ID = "id",
  /** column name */
  IS_FLAGGED = "is_flagged",
  /** column name */
  KEYWORDS = "keywords",
  /** column name */
  MONTH = "month",
  /** column name */
  PAGE_COUNT = "page_count",
  /** column name */
  PDF_URL = "pdf_url",
  /** column name */
  PUBLISHED_AT = "published_at",
  /** column name */
  PUBLISHED_IN = "published_in",
  /** column name */
  SUMMARY = "summary",
  /** column name */
  TABLE_COUNT = "table_count",
  /** column name */
  TITLE = "title",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  VERSION = "version",
  /** column name */
  YEAR = "year",
}

export type ResearchUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<ResearchAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<ResearchDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<ResearchDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<ResearchDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<ResearchIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<ResearchPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<ResearchSetInput>;
  /** filter the rows which have to be updated */
  where: ResearchBoolExp;
};

/** aggregate var_pop on columns */
export type ResearchVarPopFields = {
  __typename?: "research_var_pop_fields";
  figure_count?: Maybe<Scalars["Float"]["output"]>;
  page_count?: Maybe<Scalars["Float"]["output"]>;
  table_count?: Maybe<Scalars["Float"]["output"]>;
  version?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type ResearchVarSampFields = {
  __typename?: "research_var_samp_fields";
  figure_count?: Maybe<Scalars["Float"]["output"]>;
  page_count?: Maybe<Scalars["Float"]["output"]>;
  table_count?: Maybe<Scalars["Float"]["output"]>;
  version?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type ResearchVarianceFields = {
  __typename?: "research_variance_fields";
  figure_count?: Maybe<Scalars["Float"]["output"]>;
  page_count?: Maybe<Scalars["Float"]["output"]>;
  table_count?: Maybe<Scalars["Float"]["output"]>;
  version?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "responses" */
export type Responses = {
  __typename?: "responses";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  downvotes?: Maybe<Scalars["Int"]["output"]>;
  id: Scalars["bigint"]["output"];
  output: Scalars["String"]["output"];
  /** An object relationship */
  search: Searches;
  search_id: Scalars["bigint"]["output"];
  upvotes?: Maybe<Scalars["Int"]["output"]>;
};

/** aggregated selection of "responses" */
export type ResponsesAggregate = {
  __typename?: "responses_aggregate";
  aggregate?: Maybe<ResponsesAggregateFields>;
  nodes: Array<Responses>;
};

export type ResponsesAggregateBoolExp = {
  count?: InputMaybe<ResponsesAggregateBoolExpCount>;
};

export type ResponsesAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<ResponsesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<ResponsesBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "responses" */
export type ResponsesAggregateFields = {
  __typename?: "responses_aggregate_fields";
  avg?: Maybe<ResponsesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ResponsesMaxFields>;
  min?: Maybe<ResponsesMinFields>;
  stddev?: Maybe<ResponsesStddevFields>;
  stddev_pop?: Maybe<ResponsesStddevPopFields>;
  stddev_samp?: Maybe<ResponsesStddevSampFields>;
  sum?: Maybe<ResponsesSumFields>;
  var_pop?: Maybe<ResponsesVarPopFields>;
  var_samp?: Maybe<ResponsesVarSampFields>;
  variance?: Maybe<ResponsesVarianceFields>;
};

/** aggregate fields of "responses" */
export type ResponsesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ResponsesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "responses" */
export type ResponsesAggregateOrderBy = {
  avg?: InputMaybe<ResponsesAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<ResponsesMaxOrderBy>;
  min?: InputMaybe<ResponsesMinOrderBy>;
  stddev?: InputMaybe<ResponsesStddevOrderBy>;
  stddev_pop?: InputMaybe<ResponsesStddevPopOrderBy>;
  stddev_samp?: InputMaybe<ResponsesStddevSampOrderBy>;
  sum?: InputMaybe<ResponsesSumOrderBy>;
  var_pop?: InputMaybe<ResponsesVarPopOrderBy>;
  var_samp?: InputMaybe<ResponsesVarSampOrderBy>;
  variance?: InputMaybe<ResponsesVarianceOrderBy>;
};

/** input type for inserting array relation for remote table "responses" */
export type ResponsesArrRelInsertInput = {
  data: Array<ResponsesInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<ResponsesOnConflict>;
};

/** aggregate avg on columns */
export type ResponsesAvgFields = {
  __typename?: "responses_avg_fields";
  downvotes?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  search_id?: Maybe<Scalars["Float"]["output"]>;
  upvotes?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "responses" */
export type ResponsesAvgOrderBy = {
  downvotes?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  search_id?: InputMaybe<OrderBy>;
  upvotes?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "responses". All fields are combined with a logical 'AND'. */
export type ResponsesBoolExp = {
  _and?: InputMaybe<Array<ResponsesBoolExp>>;
  _not?: InputMaybe<ResponsesBoolExp>;
  _or?: InputMaybe<Array<ResponsesBoolExp>>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  downvotes?: InputMaybe<IntComparisonExp>;
  id?: InputMaybe<BigintComparisonExp>;
  output?: InputMaybe<StringComparisonExp>;
  search?: InputMaybe<SearchesBoolExp>;
  search_id?: InputMaybe<BigintComparisonExp>;
  upvotes?: InputMaybe<IntComparisonExp>;
};

/** unique or primary key constraints on table "responses" */
export enum ResponsesConstraint {
  /** unique or primary key constraint on columns "id" */
  RESPONSES_ID_KEY = "responses_id_key",
  /** unique or primary key constraint on columns "id" */
  RESPONSES_PKEY = "responses_pkey",
}

/** input type for incrementing numeric columns in table "responses" */
export type ResponsesIncInput = {
  downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  search_id?: InputMaybe<Scalars["bigint"]["input"]>;
  upvotes?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "responses" */
export type ResponsesInsertInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  output?: InputMaybe<Scalars["String"]["input"]>;
  search?: InputMaybe<SearchesObjRelInsertInput>;
  search_id?: InputMaybe<Scalars["bigint"]["input"]>;
  upvotes?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate max on columns */
export type ResponsesMaxFields = {
  __typename?: "responses_max_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  downvotes?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  output?: Maybe<Scalars["String"]["output"]>;
  search_id?: Maybe<Scalars["bigint"]["output"]>;
  upvotes?: Maybe<Scalars["Int"]["output"]>;
};

/** order by max() on columns of table "responses" */
export type ResponsesMaxOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  downvotes?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  output?: InputMaybe<OrderBy>;
  search_id?: InputMaybe<OrderBy>;
  upvotes?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type ResponsesMinFields = {
  __typename?: "responses_min_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  downvotes?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  output?: Maybe<Scalars["String"]["output"]>;
  search_id?: Maybe<Scalars["bigint"]["output"]>;
  upvotes?: Maybe<Scalars["Int"]["output"]>;
};

/** order by min() on columns of table "responses" */
export type ResponsesMinOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  downvotes?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  output?: InputMaybe<OrderBy>;
  search_id?: InputMaybe<OrderBy>;
  upvotes?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "responses" */
export type ResponsesMutationResponse = {
  __typename?: "responses_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Responses>;
};

/** on_conflict condition type for table "responses" */
export type ResponsesOnConflict = {
  constraint: ResponsesConstraint;
  update_columns?: Array<ResponsesUpdateColumn>;
  where?: InputMaybe<ResponsesBoolExp>;
};

/** Ordering options when selecting data from "responses". */
export type ResponsesOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  downvotes?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  output?: InputMaybe<OrderBy>;
  search?: InputMaybe<SearchesOrderBy>;
  search_id?: InputMaybe<OrderBy>;
  upvotes?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: responses */
export type ResponsesPkColumnsInput = {
  id: Scalars["bigint"]["input"];
};

/** select columns of table "responses" */
export enum ResponsesSelectColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DOWNVOTES = "downvotes",
  /** column name */
  ID = "id",
  /** column name */
  OUTPUT = "output",
  /** column name */
  SEARCH_ID = "search_id",
  /** column name */
  UPVOTES = "upvotes",
}

/** input type for updating data in table "responses" */
export type ResponsesSetInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  output?: InputMaybe<Scalars["String"]["input"]>;
  search_id?: InputMaybe<Scalars["bigint"]["input"]>;
  upvotes?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate stddev on columns */
export type ResponsesStddevFields = {
  __typename?: "responses_stddev_fields";
  downvotes?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  search_id?: Maybe<Scalars["Float"]["output"]>;
  upvotes?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "responses" */
export type ResponsesStddevOrderBy = {
  downvotes?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  search_id?: InputMaybe<OrderBy>;
  upvotes?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type ResponsesStddevPopFields = {
  __typename?: "responses_stddev_pop_fields";
  downvotes?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  search_id?: Maybe<Scalars["Float"]["output"]>;
  upvotes?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "responses" */
export type ResponsesStddevPopOrderBy = {
  downvotes?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  search_id?: InputMaybe<OrderBy>;
  upvotes?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type ResponsesStddevSampFields = {
  __typename?: "responses_stddev_samp_fields";
  downvotes?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  search_id?: Maybe<Scalars["Float"]["output"]>;
  upvotes?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "responses" */
export type ResponsesStddevSampOrderBy = {
  downvotes?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  search_id?: InputMaybe<OrderBy>;
  upvotes?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "responses" */
export type ResponsesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ResponsesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ResponsesStreamCursorValueInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  output?: InputMaybe<Scalars["String"]["input"]>;
  search_id?: InputMaybe<Scalars["bigint"]["input"]>;
  upvotes?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate sum on columns */
export type ResponsesSumFields = {
  __typename?: "responses_sum_fields";
  downvotes?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  search_id?: Maybe<Scalars["bigint"]["output"]>;
  upvotes?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "responses" */
export type ResponsesSumOrderBy = {
  downvotes?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  search_id?: InputMaybe<OrderBy>;
  upvotes?: InputMaybe<OrderBy>;
};

/** update columns of table "responses" */
export enum ResponsesUpdateColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DOWNVOTES = "downvotes",
  /** column name */
  ID = "id",
  /** column name */
  OUTPUT = "output",
  /** column name */
  SEARCH_ID = "search_id",
  /** column name */
  UPVOTES = "upvotes",
}

export type ResponsesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<ResponsesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<ResponsesSetInput>;
  /** filter the rows which have to be updated */
  where: ResponsesBoolExp;
};

/** aggregate var_pop on columns */
export type ResponsesVarPopFields = {
  __typename?: "responses_var_pop_fields";
  downvotes?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  search_id?: Maybe<Scalars["Float"]["output"]>;
  upvotes?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "responses" */
export type ResponsesVarPopOrderBy = {
  downvotes?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  search_id?: InputMaybe<OrderBy>;
  upvotes?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type ResponsesVarSampFields = {
  __typename?: "responses_var_samp_fields";
  downvotes?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  search_id?: Maybe<Scalars["Float"]["output"]>;
  upvotes?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "responses" */
export type ResponsesVarSampOrderBy = {
  downvotes?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  search_id?: InputMaybe<OrderBy>;
  upvotes?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type ResponsesVarianceFields = {
  __typename?: "responses_variance_fields";
  downvotes?: Maybe<Scalars["Float"]["output"]>;
  id?: Maybe<Scalars["Float"]["output"]>;
  search_id?: Maybe<Scalars["Float"]["output"]>;
  upvotes?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "responses" */
export type ResponsesVarianceOrderBy = {
  downvotes?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  search_id?: InputMaybe<OrderBy>;
  upvotes?: InputMaybe<OrderBy>;
};

/** columns and relationships of "role_hierarchy" */
export type RoleHierarchy = {
  __typename?: "role_hierarchy";
  child_role: Scalars["app_role_enum"]["output"];
  parent_role: Scalars["app_role_enum"]["output"];
};

/** aggregated selection of "role_hierarchy" */
export type RoleHierarchyAggregate = {
  __typename?: "role_hierarchy_aggregate";
  aggregate?: Maybe<RoleHierarchyAggregateFields>;
  nodes: Array<RoleHierarchy>;
};

/** aggregate fields of "role_hierarchy" */
export type RoleHierarchyAggregateFields = {
  __typename?: "role_hierarchy_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<RoleHierarchyMaxFields>;
  min?: Maybe<RoleHierarchyMinFields>;
};

/** aggregate fields of "role_hierarchy" */
export type RoleHierarchyAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<RoleHierarchySelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** Boolean expression to filter rows from the table "role_hierarchy". All fields are combined with a logical 'AND'. */
export type RoleHierarchyBoolExp = {
  _and?: InputMaybe<Array<RoleHierarchyBoolExp>>;
  _not?: InputMaybe<RoleHierarchyBoolExp>;
  _or?: InputMaybe<Array<RoleHierarchyBoolExp>>;
  child_role?: InputMaybe<AppRoleEnumComparisonExp>;
  parent_role?: InputMaybe<AppRoleEnumComparisonExp>;
};

/** unique or primary key constraints on table "role_hierarchy" */
export enum RoleHierarchyConstraint {
  /** unique or primary key constraint on columns "parent_role", "child_role" */
  ROLE_HIERARCHY_PKEY = "role_hierarchy_pkey",
}

/** input type for inserting data into table "role_hierarchy" */
export type RoleHierarchyInsertInput = {
  child_role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  parent_role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
};

/** aggregate max on columns */
export type RoleHierarchyMaxFields = {
  __typename?: "role_hierarchy_max_fields";
  child_role?: Maybe<Scalars["app_role_enum"]["output"]>;
  parent_role?: Maybe<Scalars["app_role_enum"]["output"]>;
};

/** aggregate min on columns */
export type RoleHierarchyMinFields = {
  __typename?: "role_hierarchy_min_fields";
  child_role?: Maybe<Scalars["app_role_enum"]["output"]>;
  parent_role?: Maybe<Scalars["app_role_enum"]["output"]>;
};

/** response of any mutation on the table "role_hierarchy" */
export type RoleHierarchyMutationResponse = {
  __typename?: "role_hierarchy_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<RoleHierarchy>;
};

/** on_conflict condition type for table "role_hierarchy" */
export type RoleHierarchyOnConflict = {
  constraint: RoleHierarchyConstraint;
  update_columns?: Array<RoleHierarchyUpdateColumn>;
  where?: InputMaybe<RoleHierarchyBoolExp>;
};

/** Ordering options when selecting data from "role_hierarchy". */
export type RoleHierarchyOrderBy = {
  child_role?: InputMaybe<OrderBy>;
  parent_role?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: role_hierarchy */
export type RoleHierarchyPkColumnsInput = {
  child_role: Scalars["app_role_enum"]["input"];
  parent_role: Scalars["app_role_enum"]["input"];
};

/** select columns of table "role_hierarchy" */
export enum RoleHierarchySelectColumn {
  /** column name */
  CHILD_ROLE = "child_role",
  /** column name */
  PARENT_ROLE = "parent_role",
}

/** input type for updating data in table "role_hierarchy" */
export type RoleHierarchySetInput = {
  child_role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  parent_role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
};

/** Streaming cursor of the table "role_hierarchy" */
export type RoleHierarchyStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: RoleHierarchyStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type RoleHierarchyStreamCursorValueInput = {
  child_role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  parent_role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
};

/** update columns of table "role_hierarchy" */
export enum RoleHierarchyUpdateColumn {
  /** column name */
  CHILD_ROLE = "child_role",
  /** column name */
  PARENT_ROLE = "parent_role",
}

export type RoleHierarchyUpdates = {
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<RoleHierarchySetInput>;
  /** filter the rows which have to be updated */
  where: RoleHierarchyBoolExp;
};

/** columns and relationships of "role_permissions" */
export type RolePermissions = {
  __typename?: "role_permissions";
  cached_permissions?: Maybe<Scalars["jsonb"]["output"]>;
  conditions?: Maybe<Scalars["jsonb"]["output"]>;
  id: Scalars["Int"]["output"];
  inherit_from?: Maybe<Array<Scalars["app_role_enum"]["output"]>>;
  last_updated?: Maybe<Scalars["timestamptz"]["output"]>;
  permissions?: Maybe<Scalars["jsonb"]["output"]>;
  role: Scalars["app_role_enum"]["output"];
  table_name: Scalars["String"]["output"];
};

/** columns and relationships of "role_permissions" */
export type RolePermissionsCachedPermissionsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "role_permissions" */
export type RolePermissionsConditionsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "role_permissions" */
export type RolePermissionsPermissionsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "role_permissions" */
export type RolePermissionsAggregate = {
  __typename?: "role_permissions_aggregate";
  aggregate?: Maybe<RolePermissionsAggregateFields>;
  nodes: Array<RolePermissions>;
};

/** aggregate fields of "role_permissions" */
export type RolePermissionsAggregateFields = {
  __typename?: "role_permissions_aggregate_fields";
  avg?: Maybe<RolePermissionsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<RolePermissionsMaxFields>;
  min?: Maybe<RolePermissionsMinFields>;
  stddev?: Maybe<RolePermissionsStddevFields>;
  stddev_pop?: Maybe<RolePermissionsStddevPopFields>;
  stddev_samp?: Maybe<RolePermissionsStddevSampFields>;
  sum?: Maybe<RolePermissionsSumFields>;
  var_pop?: Maybe<RolePermissionsVarPopFields>;
  var_samp?: Maybe<RolePermissionsVarSampFields>;
  variance?: Maybe<RolePermissionsVarianceFields>;
};

/** aggregate fields of "role_permissions" */
export type RolePermissionsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<RolePermissionsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type RolePermissionsAppendInput = {
  cached_permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  conditions?: InputMaybe<Scalars["jsonb"]["input"]>;
  permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** aggregate avg on columns */
export type RolePermissionsAvgFields = {
  __typename?: "role_permissions_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "role_permissions". All fields are combined with a logical 'AND'. */
export type RolePermissionsBoolExp = {
  _and?: InputMaybe<Array<RolePermissionsBoolExp>>;
  _not?: InputMaybe<RolePermissionsBoolExp>;
  _or?: InputMaybe<Array<RolePermissionsBoolExp>>;
  cached_permissions?: InputMaybe<JsonbComparisonExp>;
  conditions?: InputMaybe<JsonbComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  inherit_from?: InputMaybe<AppRoleEnumArrayComparisonExp>;
  last_updated?: InputMaybe<TimestamptzComparisonExp>;
  permissions?: InputMaybe<JsonbComparisonExp>;
  role?: InputMaybe<AppRoleEnumComparisonExp>;
  table_name?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "role_permissions" */
export enum RolePermissionsConstraint {
  /** unique or primary key constraint on columns "id" */
  ROLE_PERMISSIONS_PKEY = "role_permissions_pkey",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type RolePermissionsDeleteAtPathInput = {
  cached_permissions?: InputMaybe<Array<Scalars["String"]["input"]>>;
  conditions?: InputMaybe<Array<Scalars["String"]["input"]>>;
  permissions?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type RolePermissionsDeleteElemInput = {
  cached_permissions?: InputMaybe<Scalars["Int"]["input"]>;
  conditions?: InputMaybe<Scalars["Int"]["input"]>;
  permissions?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type RolePermissionsDeleteKeyInput = {
  cached_permissions?: InputMaybe<Scalars["String"]["input"]>;
  conditions?: InputMaybe<Scalars["String"]["input"]>;
  permissions?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for incrementing numeric columns in table "role_permissions" */
export type RolePermissionsIncInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "role_permissions" */
export type RolePermissionsInsertInput = {
  cached_permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  conditions?: InputMaybe<Scalars["jsonb"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  inherit_from?: InputMaybe<Array<Scalars["app_role_enum"]["input"]>>;
  last_updated?: InputMaybe<Scalars["timestamptz"]["input"]>;
  permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  table_name?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "role_permissions_materialized" */
export type RolePermissionsMaterialized = {
  __typename?: "role_permissions_materialized";
  last_updated?: Maybe<Scalars["timestamptz"]["output"]>;
  permissions: Scalars["jsonb"]["output"];
  role: Scalars["app_role_enum"]["output"];
};

/** columns and relationships of "role_permissions_materialized" */
export type RolePermissionsMaterializedPermissionsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "role_permissions_materialized" */
export type RolePermissionsMaterializedAggregate = {
  __typename?: "role_permissions_materialized_aggregate";
  aggregate?: Maybe<RolePermissionsMaterializedAggregateFields>;
  nodes: Array<RolePermissionsMaterialized>;
};

/** aggregate fields of "role_permissions_materialized" */
export type RolePermissionsMaterializedAggregateFields = {
  __typename?: "role_permissions_materialized_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<RolePermissionsMaterializedMaxFields>;
  min?: Maybe<RolePermissionsMaterializedMinFields>;
};

/** aggregate fields of "role_permissions_materialized" */
export type RolePermissionsMaterializedAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<RolePermissionsMaterializedSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type RolePermissionsMaterializedAppendInput = {
  permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** Boolean expression to filter rows from the table "role_permissions_materialized". All fields are combined with a logical 'AND'. */
export type RolePermissionsMaterializedBoolExp = {
  _and?: InputMaybe<Array<RolePermissionsMaterializedBoolExp>>;
  _not?: InputMaybe<RolePermissionsMaterializedBoolExp>;
  _or?: InputMaybe<Array<RolePermissionsMaterializedBoolExp>>;
  last_updated?: InputMaybe<TimestamptzComparisonExp>;
  permissions?: InputMaybe<JsonbComparisonExp>;
  role?: InputMaybe<AppRoleEnumComparisonExp>;
};

/** unique or primary key constraints on table "role_permissions_materialized" */
export enum RolePermissionsMaterializedConstraint {
  /** unique or primary key constraint on columns "role" */
  ROLE_PERMISSIONS_MATERIALIZED_PKEY = "role_permissions_materialized_pkey",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type RolePermissionsMaterializedDeleteAtPathInput = {
  permissions?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type RolePermissionsMaterializedDeleteElemInput = {
  permissions?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type RolePermissionsMaterializedDeleteKeyInput = {
  permissions?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for inserting data into table "role_permissions_materialized" */
export type RolePermissionsMaterializedInsertInput = {
  last_updated?: InputMaybe<Scalars["timestamptz"]["input"]>;
  permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
};

/** aggregate max on columns */
export type RolePermissionsMaterializedMaxFields = {
  __typename?: "role_permissions_materialized_max_fields";
  last_updated?: Maybe<Scalars["timestamptz"]["output"]>;
  role?: Maybe<Scalars["app_role_enum"]["output"]>;
};

/** aggregate min on columns */
export type RolePermissionsMaterializedMinFields = {
  __typename?: "role_permissions_materialized_min_fields";
  last_updated?: Maybe<Scalars["timestamptz"]["output"]>;
  role?: Maybe<Scalars["app_role_enum"]["output"]>;
};

/** response of any mutation on the table "role_permissions_materialized" */
export type RolePermissionsMaterializedMutationResponse = {
  __typename?: "role_permissions_materialized_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<RolePermissionsMaterialized>;
};

/** on_conflict condition type for table "role_permissions_materialized" */
export type RolePermissionsMaterializedOnConflict = {
  constraint: RolePermissionsMaterializedConstraint;
  update_columns?: Array<RolePermissionsMaterializedUpdateColumn>;
  where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
};

/** Ordering options when selecting data from "role_permissions_materialized". */
export type RolePermissionsMaterializedOrderBy = {
  last_updated?: InputMaybe<OrderBy>;
  permissions?: InputMaybe<OrderBy>;
  role?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: role_permissions_materialized */
export type RolePermissionsMaterializedPkColumnsInput = {
  role: Scalars["app_role_enum"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type RolePermissionsMaterializedPrependInput = {
  permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "role_permissions_materialized" */
export enum RolePermissionsMaterializedSelectColumn {
  /** column name */
  LAST_UPDATED = "last_updated",
  /** column name */
  PERMISSIONS = "permissions",
  /** column name */
  ROLE = "role",
}

/** input type for updating data in table "role_permissions_materialized" */
export type RolePermissionsMaterializedSetInput = {
  last_updated?: InputMaybe<Scalars["timestamptz"]["input"]>;
  permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
};

/** Streaming cursor of the table "role_permissions_materialized" */
export type RolePermissionsMaterializedStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: RolePermissionsMaterializedStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type RolePermissionsMaterializedStreamCursorValueInput = {
  last_updated?: InputMaybe<Scalars["timestamptz"]["input"]>;
  permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
};

/** update columns of table "role_permissions_materialized" */
export enum RolePermissionsMaterializedUpdateColumn {
  /** column name */
  LAST_UPDATED = "last_updated",
  /** column name */
  PERMISSIONS = "permissions",
  /** column name */
  ROLE = "role",
}

export type RolePermissionsMaterializedUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<RolePermissionsMaterializedAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<RolePermissionsMaterializedDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<RolePermissionsMaterializedDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<RolePermissionsMaterializedDeleteKeyInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<RolePermissionsMaterializedPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<RolePermissionsMaterializedSetInput>;
  /** filter the rows which have to be updated */
  where: RolePermissionsMaterializedBoolExp;
};

/** aggregate max on columns */
export type RolePermissionsMaxFields = {
  __typename?: "role_permissions_max_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
  inherit_from?: Maybe<Array<Scalars["app_role_enum"]["output"]>>;
  last_updated?: Maybe<Scalars["timestamptz"]["output"]>;
  role?: Maybe<Scalars["app_role_enum"]["output"]>;
  table_name?: Maybe<Scalars["String"]["output"]>;
};

/** aggregate min on columns */
export type RolePermissionsMinFields = {
  __typename?: "role_permissions_min_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
  inherit_from?: Maybe<Array<Scalars["app_role_enum"]["output"]>>;
  last_updated?: Maybe<Scalars["timestamptz"]["output"]>;
  role?: Maybe<Scalars["app_role_enum"]["output"]>;
  table_name?: Maybe<Scalars["String"]["output"]>;
};

/** response of any mutation on the table "role_permissions" */
export type RolePermissionsMutationResponse = {
  __typename?: "role_permissions_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<RolePermissions>;
};

/** on_conflict condition type for table "role_permissions" */
export type RolePermissionsOnConflict = {
  constraint: RolePermissionsConstraint;
  update_columns?: Array<RolePermissionsUpdateColumn>;
  where?: InputMaybe<RolePermissionsBoolExp>;
};

/** Ordering options when selecting data from "role_permissions". */
export type RolePermissionsOrderBy = {
  cached_permissions?: InputMaybe<OrderBy>;
  conditions?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  inherit_from?: InputMaybe<OrderBy>;
  last_updated?: InputMaybe<OrderBy>;
  permissions?: InputMaybe<OrderBy>;
  role?: InputMaybe<OrderBy>;
  table_name?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: role_permissions */
export type RolePermissionsPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type RolePermissionsPrependInput = {
  cached_permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  conditions?: InputMaybe<Scalars["jsonb"]["input"]>;
  permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "role_permissions" */
export enum RolePermissionsSelectColumn {
  /** column name */
  CACHED_PERMISSIONS = "cached_permissions",
  /** column name */
  CONDITIONS = "conditions",
  /** column name */
  ID = "id",
  /** column name */
  INHERIT_FROM = "inherit_from",
  /** column name */
  LAST_UPDATED = "last_updated",
  /** column name */
  PERMISSIONS = "permissions",
  /** column name */
  ROLE = "role",
  /** column name */
  TABLE_NAME = "table_name",
}

/** input type for updating data in table "role_permissions" */
export type RolePermissionsSetInput = {
  cached_permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  conditions?: InputMaybe<Scalars["jsonb"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  inherit_from?: InputMaybe<Array<Scalars["app_role_enum"]["input"]>>;
  last_updated?: InputMaybe<Scalars["timestamptz"]["input"]>;
  permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  table_name?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type RolePermissionsStddevFields = {
  __typename?: "role_permissions_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type RolePermissionsStddevPopFields = {
  __typename?: "role_permissions_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type RolePermissionsStddevSampFields = {
  __typename?: "role_permissions_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "role_permissions" */
export type RolePermissionsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: RolePermissionsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type RolePermissionsStreamCursorValueInput = {
  cached_permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  conditions?: InputMaybe<Scalars["jsonb"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  inherit_from?: InputMaybe<Array<Scalars["app_role_enum"]["input"]>>;
  last_updated?: InputMaybe<Scalars["timestamptz"]["input"]>;
  permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  table_name?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type RolePermissionsSumFields = {
  __typename?: "role_permissions_sum_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "role_permissions" */
export enum RolePermissionsUpdateColumn {
  /** column name */
  CACHED_PERMISSIONS = "cached_permissions",
  /** column name */
  CONDITIONS = "conditions",
  /** column name */
  ID = "id",
  /** column name */
  INHERIT_FROM = "inherit_from",
  /** column name */
  LAST_UPDATED = "last_updated",
  /** column name */
  PERMISSIONS = "permissions",
  /** column name */
  ROLE = "role",
  /** column name */
  TABLE_NAME = "table_name",
}

export type RolePermissionsUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<RolePermissionsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<RolePermissionsDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<RolePermissionsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<RolePermissionsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<RolePermissionsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<RolePermissionsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<RolePermissionsSetInput>;
  /** filter the rows which have to be updated */
  where: RolePermissionsBoolExp;
};

/** aggregate var_pop on columns */
export type RolePermissionsVarPopFields = {
  __typename?: "role_permissions_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type RolePermissionsVarSampFields = {
  __typename?: "role_permissions_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type RolePermissionsVarianceFields = {
  __typename?: "role_permissions_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "scoring_weights" */
export type ScoringWeights = {
  __typename?: "scoring_weights";
  description?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["uuid"]["output"];
  name: Scalars["String"]["output"];
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  weight: Scalars["float8"]["output"];
};

/** aggregated selection of "scoring_weights" */
export type ScoringWeightsAggregate = {
  __typename?: "scoring_weights_aggregate";
  aggregate?: Maybe<ScoringWeightsAggregateFields>;
  nodes: Array<ScoringWeights>;
};

/** aggregate fields of "scoring_weights" */
export type ScoringWeightsAggregateFields = {
  __typename?: "scoring_weights_aggregate_fields";
  avg?: Maybe<ScoringWeightsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<ScoringWeightsMaxFields>;
  min?: Maybe<ScoringWeightsMinFields>;
  stddev?: Maybe<ScoringWeightsStddevFields>;
  stddev_pop?: Maybe<ScoringWeightsStddevPopFields>;
  stddev_samp?: Maybe<ScoringWeightsStddevSampFields>;
  sum?: Maybe<ScoringWeightsSumFields>;
  var_pop?: Maybe<ScoringWeightsVarPopFields>;
  var_samp?: Maybe<ScoringWeightsVarSampFields>;
  variance?: Maybe<ScoringWeightsVarianceFields>;
};

/** aggregate fields of "scoring_weights" */
export type ScoringWeightsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<ScoringWeightsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type ScoringWeightsAvgFields = {
  __typename?: "scoring_weights_avg_fields";
  weight?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "scoring_weights". All fields are combined with a logical 'AND'. */
export type ScoringWeightsBoolExp = {
  _and?: InputMaybe<Array<ScoringWeightsBoolExp>>;
  _not?: InputMaybe<ScoringWeightsBoolExp>;
  _or?: InputMaybe<Array<ScoringWeightsBoolExp>>;
  description?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  weight?: InputMaybe<Float8ComparisonExp>;
};

/** unique or primary key constraints on table "scoring_weights" */
export enum ScoringWeightsConstraint {
  /** unique or primary key constraint on columns "name" */
  SCORING_WEIGHTS_NAME_KEY = "scoring_weights_name_key",
  /** unique or primary key constraint on columns "id" */
  SCORING_WEIGHTS_PKEY = "scoring_weights_pkey",
}

/** input type for incrementing numeric columns in table "scoring_weights" */
export type ScoringWeightsIncInput = {
  weight?: InputMaybe<Scalars["float8"]["input"]>;
};

/** input type for inserting data into table "scoring_weights" */
export type ScoringWeightsInsertInput = {
  description?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  weight?: InputMaybe<Scalars["float8"]["input"]>;
};

/** aggregate max on columns */
export type ScoringWeightsMaxFields = {
  __typename?: "scoring_weights_max_fields";
  description?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  weight?: Maybe<Scalars["float8"]["output"]>;
};

/** aggregate min on columns */
export type ScoringWeightsMinFields = {
  __typename?: "scoring_weights_min_fields";
  description?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  weight?: Maybe<Scalars["float8"]["output"]>;
};

/** response of any mutation on the table "scoring_weights" */
export type ScoringWeightsMutationResponse = {
  __typename?: "scoring_weights_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<ScoringWeights>;
};

/** on_conflict condition type for table "scoring_weights" */
export type ScoringWeightsOnConflict = {
  constraint: ScoringWeightsConstraint;
  update_columns?: Array<ScoringWeightsUpdateColumn>;
  where?: InputMaybe<ScoringWeightsBoolExp>;
};

/** Ordering options when selecting data from "scoring_weights". */
export type ScoringWeightsOrderBy = {
  description?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  weight?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: scoring_weights */
export type ScoringWeightsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "scoring_weights" */
export enum ScoringWeightsSelectColumn {
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  WEIGHT = "weight",
}

/** input type for updating data in table "scoring_weights" */
export type ScoringWeightsSetInput = {
  description?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  weight?: InputMaybe<Scalars["float8"]["input"]>;
};

/** aggregate stddev on columns */
export type ScoringWeightsStddevFields = {
  __typename?: "scoring_weights_stddev_fields";
  weight?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type ScoringWeightsStddevPopFields = {
  __typename?: "scoring_weights_stddev_pop_fields";
  weight?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type ScoringWeightsStddevSampFields = {
  __typename?: "scoring_weights_stddev_samp_fields";
  weight?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "scoring_weights" */
export type ScoringWeightsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: ScoringWeightsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type ScoringWeightsStreamCursorValueInput = {
  description?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  weight?: InputMaybe<Scalars["float8"]["input"]>;
};

/** aggregate sum on columns */
export type ScoringWeightsSumFields = {
  __typename?: "scoring_weights_sum_fields";
  weight?: Maybe<Scalars["float8"]["output"]>;
};

/** update columns of table "scoring_weights" */
export enum ScoringWeightsUpdateColumn {
  /** column name */
  DESCRIPTION = "description",
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  WEIGHT = "weight",
}

export type ScoringWeightsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<ScoringWeightsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<ScoringWeightsSetInput>;
  /** filter the rows which have to be updated */
  where: ScoringWeightsBoolExp;
};

/** aggregate var_pop on columns */
export type ScoringWeightsVarPopFields = {
  __typename?: "scoring_weights_var_pop_fields";
  weight?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type ScoringWeightsVarSampFields = {
  __typename?: "scoring_weights_var_samp_fields";
  weight?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type ScoringWeightsVarianceFields = {
  __typename?: "scoring_weights_variance_fields";
  weight?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to compare columns of type "scrape_frequency". All fields are combined with logical 'AND'. */
export type ScrapeFrequencyComparisonExp = {
  _eq?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  _gt?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  _gte?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  _in?: InputMaybe<Array<Scalars["scrape_frequency"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  _lte?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  _neq?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["scrape_frequency"]["input"]>>;
};

/** columns and relationships of "searches" */
export type Searches = {
  __typename?: "searches";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  embedding?: Maybe<Scalars["vector"]["output"]>;
  id: Scalars["bigint"]["output"];
  input: Scalars["String"]["output"];
  /** An array relationship */
  responses: Array<Responses>;
  /** An aggregate relationship */
  responses_aggregate: ResponsesAggregate;
  tokens_used?: Maybe<Scalars["smallint"]["output"]>;
  user_ids?: Maybe<Array<Scalars["uuid"]["output"]>>;
};

/** columns and relationships of "searches" */
export type SearchesResponsesArgs = {
  distinct_on?: InputMaybe<Array<ResponsesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResponsesOrderBy>>;
  where?: InputMaybe<ResponsesBoolExp>;
};

/** columns and relationships of "searches" */
export type SearchesResponsesAggregateArgs = {
  distinct_on?: InputMaybe<Array<ResponsesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResponsesOrderBy>>;
  where?: InputMaybe<ResponsesBoolExp>;
};

/** aggregated selection of "searches" */
export type SearchesAggregate = {
  __typename?: "searches_aggregate";
  aggregate?: Maybe<SearchesAggregateFields>;
  nodes: Array<Searches>;
};

/** aggregate fields of "searches" */
export type SearchesAggregateFields = {
  __typename?: "searches_aggregate_fields";
  avg?: Maybe<SearchesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<SearchesMaxFields>;
  min?: Maybe<SearchesMinFields>;
  stddev?: Maybe<SearchesStddevFields>;
  stddev_pop?: Maybe<SearchesStddevPopFields>;
  stddev_samp?: Maybe<SearchesStddevSampFields>;
  sum?: Maybe<SearchesSumFields>;
  var_pop?: Maybe<SearchesVarPopFields>;
  var_samp?: Maybe<SearchesVarSampFields>;
  variance?: Maybe<SearchesVarianceFields>;
};

/** aggregate fields of "searches" */
export type SearchesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<SearchesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type SearchesAvgFields = {
  __typename?: "searches_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  tokens_used?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "searches". All fields are combined with a logical 'AND'. */
export type SearchesBoolExp = {
  _and?: InputMaybe<Array<SearchesBoolExp>>;
  _not?: InputMaybe<SearchesBoolExp>;
  _or?: InputMaybe<Array<SearchesBoolExp>>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  embedding?: InputMaybe<VectorComparisonExp>;
  id?: InputMaybe<BigintComparisonExp>;
  input?: InputMaybe<StringComparisonExp>;
  responses?: InputMaybe<ResponsesBoolExp>;
  responses_aggregate?: InputMaybe<ResponsesAggregateBoolExp>;
  tokens_used?: InputMaybe<SmallintComparisonExp>;
  user_ids?: InputMaybe<UuidArrayComparisonExp>;
};

/** unique or primary key constraints on table "searches" */
export enum SearchesConstraint {
  /** unique or primary key constraint on columns "input" */
  SEARCHES_INPUT_KEY = "searches_input_key",
  /** unique or primary key constraint on columns "id" */
  SEARCHES_PKEY = "searches_pkey",
}

/** input type for incrementing numeric columns in table "searches" */
export type SearchesIncInput = {
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  tokens_used?: InputMaybe<Scalars["smallint"]["input"]>;
};

/** input type for inserting data into table "searches" */
export type SearchesInsertInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  embedding?: InputMaybe<Scalars["vector"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  input?: InputMaybe<Scalars["String"]["input"]>;
  responses?: InputMaybe<ResponsesArrRelInsertInput>;
  tokens_used?: InputMaybe<Scalars["smallint"]["input"]>;
  user_ids?: InputMaybe<Array<Scalars["uuid"]["input"]>>;
};

/** aggregate max on columns */
export type SearchesMaxFields = {
  __typename?: "searches_max_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  input?: Maybe<Scalars["String"]["output"]>;
  tokens_used?: Maybe<Scalars["smallint"]["output"]>;
  user_ids?: Maybe<Array<Scalars["uuid"]["output"]>>;
};

/** aggregate min on columns */
export type SearchesMinFields = {
  __typename?: "searches_min_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  input?: Maybe<Scalars["String"]["output"]>;
  tokens_used?: Maybe<Scalars["smallint"]["output"]>;
  user_ids?: Maybe<Array<Scalars["uuid"]["output"]>>;
};

/** response of any mutation on the table "searches" */
export type SearchesMutationResponse = {
  __typename?: "searches_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Searches>;
};

/** input type for inserting object relation for remote table "searches" */
export type SearchesObjRelInsertInput = {
  data: SearchesInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<SearchesOnConflict>;
};

/** on_conflict condition type for table "searches" */
export type SearchesOnConflict = {
  constraint: SearchesConstraint;
  update_columns?: Array<SearchesUpdateColumn>;
  where?: InputMaybe<SearchesBoolExp>;
};

/** Ordering options when selecting data from "searches". */
export type SearchesOrderBy = {
  created_at?: InputMaybe<OrderBy>;
  embedding?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  input?: InputMaybe<OrderBy>;
  responses_aggregate?: InputMaybe<ResponsesAggregateOrderBy>;
  tokens_used?: InputMaybe<OrderBy>;
  user_ids?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: searches */
export type SearchesPkColumnsInput = {
  id: Scalars["bigint"]["input"];
};

/** select columns of table "searches" */
export enum SearchesSelectColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  EMBEDDING = "embedding",
  /** column name */
  ID = "id",
  /** column name */
  INPUT = "input",
  /** column name */
  TOKENS_USED = "tokens_used",
  /** column name */
  USER_IDS = "user_ids",
}

/** input type for updating data in table "searches" */
export type SearchesSetInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  embedding?: InputMaybe<Scalars["vector"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  input?: InputMaybe<Scalars["String"]["input"]>;
  tokens_used?: InputMaybe<Scalars["smallint"]["input"]>;
  user_ids?: InputMaybe<Array<Scalars["uuid"]["input"]>>;
};

/** aggregate stddev on columns */
export type SearchesStddevFields = {
  __typename?: "searches_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  tokens_used?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type SearchesStddevPopFields = {
  __typename?: "searches_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  tokens_used?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type SearchesStddevSampFields = {
  __typename?: "searches_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  tokens_used?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "searches" */
export type SearchesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: SearchesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type SearchesStreamCursorValueInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  embedding?: InputMaybe<Scalars["vector"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  input?: InputMaybe<Scalars["String"]["input"]>;
  tokens_used?: InputMaybe<Scalars["smallint"]["input"]>;
  user_ids?: InputMaybe<Array<Scalars["uuid"]["input"]>>;
};

/** aggregate sum on columns */
export type SearchesSumFields = {
  __typename?: "searches_sum_fields";
  id?: Maybe<Scalars["bigint"]["output"]>;
  tokens_used?: Maybe<Scalars["smallint"]["output"]>;
};

/** update columns of table "searches" */
export enum SearchesUpdateColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  EMBEDDING = "embedding",
  /** column name */
  ID = "id",
  /** column name */
  INPUT = "input",
  /** column name */
  TOKENS_USED = "tokens_used",
  /** column name */
  USER_IDS = "user_ids",
}

export type SearchesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<SearchesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<SearchesSetInput>;
  /** filter the rows which have to be updated */
  where: SearchesBoolExp;
};

/** aggregate var_pop on columns */
export type SearchesVarPopFields = {
  __typename?: "searches_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  tokens_used?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type SearchesVarSampFields = {
  __typename?: "searches_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  tokens_used?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type SearchesVarianceFields = {
  __typename?: "searches_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  tokens_used?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "security_metrics" */
export type SecurityMetrics = {
  __typename?: "security_metrics";
  high_attempt_count?: Maybe<Scalars["bigint"]["output"]>;
  max_attempts?: Maybe<Scalars["Int"]["output"]>;
  suspicious_attempts?: Maybe<Scalars["bigint"]["output"]>;
  time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
  total_attempts?: Maybe<Scalars["bigint"]["output"]>;
  unique_ips?: Maybe<Scalars["bigint"]["output"]>;
  unique_referrers?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregated selection of "security_metrics" */
export type SecurityMetricsAggregate = {
  __typename?: "security_metrics_aggregate";
  aggregate?: Maybe<SecurityMetricsAggregateFields>;
  nodes: Array<SecurityMetrics>;
};

/** aggregate fields of "security_metrics" */
export type SecurityMetricsAggregateFields = {
  __typename?: "security_metrics_aggregate_fields";
  avg?: Maybe<SecurityMetricsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<SecurityMetricsMaxFields>;
  min?: Maybe<SecurityMetricsMinFields>;
  stddev?: Maybe<SecurityMetricsStddevFields>;
  stddev_pop?: Maybe<SecurityMetricsStddevPopFields>;
  stddev_samp?: Maybe<SecurityMetricsStddevSampFields>;
  sum?: Maybe<SecurityMetricsSumFields>;
  var_pop?: Maybe<SecurityMetricsVarPopFields>;
  var_samp?: Maybe<SecurityMetricsVarSampFields>;
  variance?: Maybe<SecurityMetricsVarianceFields>;
};

/** aggregate fields of "security_metrics" */
export type SecurityMetricsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<SecurityMetricsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type SecurityMetricsAvgFields = {
  __typename?: "security_metrics_avg_fields";
  high_attempt_count?: Maybe<Scalars["Float"]["output"]>;
  max_attempts?: Maybe<Scalars["Float"]["output"]>;
  suspicious_attempts?: Maybe<Scalars["Float"]["output"]>;
  total_attempts?: Maybe<Scalars["Float"]["output"]>;
  unique_ips?: Maybe<Scalars["Float"]["output"]>;
  unique_referrers?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "security_metrics". All fields are combined with a logical 'AND'. */
export type SecurityMetricsBoolExp = {
  _and?: InputMaybe<Array<SecurityMetricsBoolExp>>;
  _not?: InputMaybe<SecurityMetricsBoolExp>;
  _or?: InputMaybe<Array<SecurityMetricsBoolExp>>;
  high_attempt_count?: InputMaybe<BigintComparisonExp>;
  max_attempts?: InputMaybe<IntComparisonExp>;
  suspicious_attempts?: InputMaybe<BigintComparisonExp>;
  time_bucket?: InputMaybe<TimestamptzComparisonExp>;
  total_attempts?: InputMaybe<BigintComparisonExp>;
  unique_ips?: InputMaybe<BigintComparisonExp>;
  unique_referrers?: InputMaybe<BigintComparisonExp>;
};

/** aggregate max on columns */
export type SecurityMetricsMaxFields = {
  __typename?: "security_metrics_max_fields";
  high_attempt_count?: Maybe<Scalars["bigint"]["output"]>;
  max_attempts?: Maybe<Scalars["Int"]["output"]>;
  suspicious_attempts?: Maybe<Scalars["bigint"]["output"]>;
  time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
  total_attempts?: Maybe<Scalars["bigint"]["output"]>;
  unique_ips?: Maybe<Scalars["bigint"]["output"]>;
  unique_referrers?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate min on columns */
export type SecurityMetricsMinFields = {
  __typename?: "security_metrics_min_fields";
  high_attempt_count?: Maybe<Scalars["bigint"]["output"]>;
  max_attempts?: Maybe<Scalars["Int"]["output"]>;
  suspicious_attempts?: Maybe<Scalars["bigint"]["output"]>;
  time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
  total_attempts?: Maybe<Scalars["bigint"]["output"]>;
  unique_ips?: Maybe<Scalars["bigint"]["output"]>;
  unique_referrers?: Maybe<Scalars["bigint"]["output"]>;
};

/** Ordering options when selecting data from "security_metrics". */
export type SecurityMetricsOrderBy = {
  high_attempt_count?: InputMaybe<OrderBy>;
  max_attempts?: InputMaybe<OrderBy>;
  suspicious_attempts?: InputMaybe<OrderBy>;
  time_bucket?: InputMaybe<OrderBy>;
  total_attempts?: InputMaybe<OrderBy>;
  unique_ips?: InputMaybe<OrderBy>;
  unique_referrers?: InputMaybe<OrderBy>;
};

/** select columns of table "security_metrics" */
export enum SecurityMetricsSelectColumn {
  /** column name */
  HIGH_ATTEMPT_COUNT = "high_attempt_count",
  /** column name */
  MAX_ATTEMPTS = "max_attempts",
  /** column name */
  SUSPICIOUS_ATTEMPTS = "suspicious_attempts",
  /** column name */
  TIME_BUCKET = "time_bucket",
  /** column name */
  TOTAL_ATTEMPTS = "total_attempts",
  /** column name */
  UNIQUE_IPS = "unique_ips",
  /** column name */
  UNIQUE_REFERRERS = "unique_referrers",
}

/** aggregate stddev on columns */
export type SecurityMetricsStddevFields = {
  __typename?: "security_metrics_stddev_fields";
  high_attempt_count?: Maybe<Scalars["Float"]["output"]>;
  max_attempts?: Maybe<Scalars["Float"]["output"]>;
  suspicious_attempts?: Maybe<Scalars["Float"]["output"]>;
  total_attempts?: Maybe<Scalars["Float"]["output"]>;
  unique_ips?: Maybe<Scalars["Float"]["output"]>;
  unique_referrers?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type SecurityMetricsStddevPopFields = {
  __typename?: "security_metrics_stddev_pop_fields";
  high_attempt_count?: Maybe<Scalars["Float"]["output"]>;
  max_attempts?: Maybe<Scalars["Float"]["output"]>;
  suspicious_attempts?: Maybe<Scalars["Float"]["output"]>;
  total_attempts?: Maybe<Scalars["Float"]["output"]>;
  unique_ips?: Maybe<Scalars["Float"]["output"]>;
  unique_referrers?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type SecurityMetricsStddevSampFields = {
  __typename?: "security_metrics_stddev_samp_fields";
  high_attempt_count?: Maybe<Scalars["Float"]["output"]>;
  max_attempts?: Maybe<Scalars["Float"]["output"]>;
  suspicious_attempts?: Maybe<Scalars["Float"]["output"]>;
  total_attempts?: Maybe<Scalars["Float"]["output"]>;
  unique_ips?: Maybe<Scalars["Float"]["output"]>;
  unique_referrers?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "security_metrics" */
export type SecurityMetricsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: SecurityMetricsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type SecurityMetricsStreamCursorValueInput = {
  high_attempt_count?: InputMaybe<Scalars["bigint"]["input"]>;
  max_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  suspicious_attempts?: InputMaybe<Scalars["bigint"]["input"]>;
  time_bucket?: InputMaybe<Scalars["timestamptz"]["input"]>;
  total_attempts?: InputMaybe<Scalars["bigint"]["input"]>;
  unique_ips?: InputMaybe<Scalars["bigint"]["input"]>;
  unique_referrers?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** aggregate sum on columns */
export type SecurityMetricsSumFields = {
  __typename?: "security_metrics_sum_fields";
  high_attempt_count?: Maybe<Scalars["bigint"]["output"]>;
  max_attempts?: Maybe<Scalars["Int"]["output"]>;
  suspicious_attempts?: Maybe<Scalars["bigint"]["output"]>;
  total_attempts?: Maybe<Scalars["bigint"]["output"]>;
  unique_ips?: Maybe<Scalars["bigint"]["output"]>;
  unique_referrers?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate var_pop on columns */
export type SecurityMetricsVarPopFields = {
  __typename?: "security_metrics_var_pop_fields";
  high_attempt_count?: Maybe<Scalars["Float"]["output"]>;
  max_attempts?: Maybe<Scalars["Float"]["output"]>;
  suspicious_attempts?: Maybe<Scalars["Float"]["output"]>;
  total_attempts?: Maybe<Scalars["Float"]["output"]>;
  unique_ips?: Maybe<Scalars["Float"]["output"]>;
  unique_referrers?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type SecurityMetricsVarSampFields = {
  __typename?: "security_metrics_var_samp_fields";
  high_attempt_count?: Maybe<Scalars["Float"]["output"]>;
  max_attempts?: Maybe<Scalars["Float"]["output"]>;
  suspicious_attempts?: Maybe<Scalars["Float"]["output"]>;
  total_attempts?: Maybe<Scalars["Float"]["output"]>;
  unique_ips?: Maybe<Scalars["Float"]["output"]>;
  unique_referrers?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type SecurityMetricsVarianceFields = {
  __typename?: "security_metrics_variance_fields";
  high_attempt_count?: Maybe<Scalars["Float"]["output"]>;
  max_attempts?: Maybe<Scalars["Float"]["output"]>;
  suspicious_attempts?: Maybe<Scalars["Float"]["output"]>;
  total_attempts?: Maybe<Scalars["Float"]["output"]>;
  unique_ips?: Maybe<Scalars["Float"]["output"]>;
  unique_referrers?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "slow_query_patterns" */
export type SlowQueryPatterns = {
  __typename?: "slow_query_patterns";
  avg_exec_time?: Maybe<Scalars["float8"]["output"]>;
  first_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
  query_id?: Maybe<Scalars["String"]["output"]>;
};

/** aggregated selection of "slow_query_patterns" */
export type SlowQueryPatternsAggregate = {
  __typename?: "slow_query_patterns_aggregate";
  aggregate?: Maybe<SlowQueryPatternsAggregateFields>;
  nodes: Array<SlowQueryPatterns>;
};

/** aggregate fields of "slow_query_patterns" */
export type SlowQueryPatternsAggregateFields = {
  __typename?: "slow_query_patterns_aggregate_fields";
  avg?: Maybe<SlowQueryPatternsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<SlowQueryPatternsMaxFields>;
  min?: Maybe<SlowQueryPatternsMinFields>;
  stddev?: Maybe<SlowQueryPatternsStddevFields>;
  stddev_pop?: Maybe<SlowQueryPatternsStddevPopFields>;
  stddev_samp?: Maybe<SlowQueryPatternsStddevSampFields>;
  sum?: Maybe<SlowQueryPatternsSumFields>;
  var_pop?: Maybe<SlowQueryPatternsVarPopFields>;
  var_samp?: Maybe<SlowQueryPatternsVarSampFields>;
  variance?: Maybe<SlowQueryPatternsVarianceFields>;
};

/** aggregate fields of "slow_query_patterns" */
export type SlowQueryPatternsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<SlowQueryPatternsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type SlowQueryPatternsAvgFields = {
  __typename?: "slow_query_patterns_avg_fields";
  avg_exec_time?: Maybe<Scalars["Float"]["output"]>;
  max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  occurrence_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "slow_query_patterns". All fields are combined with a logical 'AND'. */
export type SlowQueryPatternsBoolExp = {
  _and?: InputMaybe<Array<SlowQueryPatternsBoolExp>>;
  _not?: InputMaybe<SlowQueryPatternsBoolExp>;
  _or?: InputMaybe<Array<SlowQueryPatternsBoolExp>>;
  avg_exec_time?: InputMaybe<Float8ComparisonExp>;
  first_seen?: InputMaybe<TimestamptzComparisonExp>;
  last_seen?: InputMaybe<TimestamptzComparisonExp>;
  max_exec_time?: InputMaybe<Float8ComparisonExp>;
  occurrence_count?: InputMaybe<BigintComparisonExp>;
  query_id?: InputMaybe<StringComparisonExp>;
};

/** aggregate max on columns */
export type SlowQueryPatternsMaxFields = {
  __typename?: "slow_query_patterns_max_fields";
  avg_exec_time?: Maybe<Scalars["float8"]["output"]>;
  first_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
  query_id?: Maybe<Scalars["String"]["output"]>;
};

/** aggregate min on columns */
export type SlowQueryPatternsMinFields = {
  __typename?: "slow_query_patterns_min_fields";
  avg_exec_time?: Maybe<Scalars["float8"]["output"]>;
  first_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
  query_id?: Maybe<Scalars["String"]["output"]>;
};

/** Ordering options when selecting data from "slow_query_patterns". */
export type SlowQueryPatternsOrderBy = {
  avg_exec_time?: InputMaybe<OrderBy>;
  first_seen?: InputMaybe<OrderBy>;
  last_seen?: InputMaybe<OrderBy>;
  max_exec_time?: InputMaybe<OrderBy>;
  occurrence_count?: InputMaybe<OrderBy>;
  query_id?: InputMaybe<OrderBy>;
};

/** select columns of table "slow_query_patterns" */
export enum SlowQueryPatternsSelectColumn {
  /** column name */
  AVG_EXEC_TIME = "avg_exec_time",
  /** column name */
  FIRST_SEEN = "first_seen",
  /** column name */
  LAST_SEEN = "last_seen",
  /** column name */
  MAX_EXEC_TIME = "max_exec_time",
  /** column name */
  OCCURRENCE_COUNT = "occurrence_count",
  /** column name */
  QUERY_ID = "query_id",
}

/** aggregate stddev on columns */
export type SlowQueryPatternsStddevFields = {
  __typename?: "slow_query_patterns_stddev_fields";
  avg_exec_time?: Maybe<Scalars["Float"]["output"]>;
  max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  occurrence_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type SlowQueryPatternsStddevPopFields = {
  __typename?: "slow_query_patterns_stddev_pop_fields";
  avg_exec_time?: Maybe<Scalars["Float"]["output"]>;
  max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  occurrence_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type SlowQueryPatternsStddevSampFields = {
  __typename?: "slow_query_patterns_stddev_samp_fields";
  avg_exec_time?: Maybe<Scalars["Float"]["output"]>;
  max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  occurrence_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "slow_query_patterns" */
export type SlowQueryPatternsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: SlowQueryPatternsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type SlowQueryPatternsStreamCursorValueInput = {
  avg_exec_time?: InputMaybe<Scalars["float8"]["input"]>;
  first_seen?: InputMaybe<Scalars["timestamptz"]["input"]>;
  last_seen?: InputMaybe<Scalars["timestamptz"]["input"]>;
  max_exec_time?: InputMaybe<Scalars["float8"]["input"]>;
  occurrence_count?: InputMaybe<Scalars["bigint"]["input"]>;
  query_id?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type SlowQueryPatternsSumFields = {
  __typename?: "slow_query_patterns_sum_fields";
  avg_exec_time?: Maybe<Scalars["float8"]["output"]>;
  max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate var_pop on columns */
export type SlowQueryPatternsVarPopFields = {
  __typename?: "slow_query_patterns_var_pop_fields";
  avg_exec_time?: Maybe<Scalars["Float"]["output"]>;
  max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  occurrence_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type SlowQueryPatternsVarSampFields = {
  __typename?: "slow_query_patterns_var_samp_fields";
  avg_exec_time?: Maybe<Scalars["Float"]["output"]>;
  max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  occurrence_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type SlowQueryPatternsVarianceFields = {
  __typename?: "slow_query_patterns_variance_fields";
  avg_exec_time?: Maybe<Scalars["Float"]["output"]>;
  max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  occurrence_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to compare columns of type "smallint". All fields are combined with logical 'AND'. */
export type SmallintComparisonExp = {
  _eq?: InputMaybe<Scalars["smallint"]["input"]>;
  _gt?: InputMaybe<Scalars["smallint"]["input"]>;
  _gte?: InputMaybe<Scalars["smallint"]["input"]>;
  _in?: InputMaybe<Array<Scalars["smallint"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["smallint"]["input"]>;
  _lte?: InputMaybe<Scalars["smallint"]["input"]>;
  _neq?: InputMaybe<Scalars["smallint"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["smallint"]["input"]>>;
};

/** columns and relationships of "social_media" */
export type SocialMedia = {
  __typename?: "social_media";
  /** An array relationship */
  companies: Array<Companies>;
  /** An aggregate relationship */
  companies_aggregate: CompaniesAggregate;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  facebook_url?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["Int"]["output"];
  instagram_url?: Maybe<Scalars["String"]["output"]>;
  linkedin_url?: Maybe<Scalars["String"]["output"]>;
  twitter_url?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  youtube_url?: Maybe<Scalars["String"]["output"]>;
};

/** columns and relationships of "social_media" */
export type SocialMediaCompaniesArgs = {
  distinct_on?: InputMaybe<Array<CompaniesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompaniesOrderBy>>;
  where?: InputMaybe<CompaniesBoolExp>;
};

/** columns and relationships of "social_media" */
export type SocialMediaCompaniesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompaniesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompaniesOrderBy>>;
  where?: InputMaybe<CompaniesBoolExp>;
};

/** aggregated selection of "social_media" */
export type SocialMediaAggregate = {
  __typename?: "social_media_aggregate";
  aggregate?: Maybe<SocialMediaAggregateFields>;
  nodes: Array<SocialMedia>;
};

/** aggregate fields of "social_media" */
export type SocialMediaAggregateFields = {
  __typename?: "social_media_aggregate_fields";
  avg?: Maybe<SocialMediaAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<SocialMediaMaxFields>;
  min?: Maybe<SocialMediaMinFields>;
  stddev?: Maybe<SocialMediaStddevFields>;
  stddev_pop?: Maybe<SocialMediaStddevPopFields>;
  stddev_samp?: Maybe<SocialMediaStddevSampFields>;
  sum?: Maybe<SocialMediaSumFields>;
  var_pop?: Maybe<SocialMediaVarPopFields>;
  var_samp?: Maybe<SocialMediaVarSampFields>;
  variance?: Maybe<SocialMediaVarianceFields>;
};

/** aggregate fields of "social_media" */
export type SocialMediaAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<SocialMediaSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type SocialMediaAvgFields = {
  __typename?: "social_media_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "social_media". All fields are combined with a logical 'AND'. */
export type SocialMediaBoolExp = {
  _and?: InputMaybe<Array<SocialMediaBoolExp>>;
  _not?: InputMaybe<SocialMediaBoolExp>;
  _or?: InputMaybe<Array<SocialMediaBoolExp>>;
  companies?: InputMaybe<CompaniesBoolExp>;
  companies_aggregate?: InputMaybe<CompaniesAggregateBoolExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  facebook_url?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  instagram_url?: InputMaybe<StringComparisonExp>;
  linkedin_url?: InputMaybe<StringComparisonExp>;
  twitter_url?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  youtube_url?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "social_media" */
export enum SocialMediaConstraint {
  /** unique or primary key constraint on columns "id" */
  SOCIAL_MEDIA_PKEY = "social_media_pkey",
}

/** input type for incrementing numeric columns in table "social_media" */
export type SocialMediaIncInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "social_media" */
export type SocialMediaInsertInput = {
  companies?: InputMaybe<CompaniesArrRelInsertInput>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  facebook_url?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  instagram_url?: InputMaybe<Scalars["String"]["input"]>;
  linkedin_url?: InputMaybe<Scalars["String"]["input"]>;
  twitter_url?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  youtube_url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type SocialMediaMaxFields = {
  __typename?: "social_media_max_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  facebook_url?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  instagram_url?: Maybe<Scalars["String"]["output"]>;
  linkedin_url?: Maybe<Scalars["String"]["output"]>;
  twitter_url?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  youtube_url?: Maybe<Scalars["String"]["output"]>;
};

/** aggregate min on columns */
export type SocialMediaMinFields = {
  __typename?: "social_media_min_fields";
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  facebook_url?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  instagram_url?: Maybe<Scalars["String"]["output"]>;
  linkedin_url?: Maybe<Scalars["String"]["output"]>;
  twitter_url?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  youtube_url?: Maybe<Scalars["String"]["output"]>;
};

/** response of any mutation on the table "social_media" */
export type SocialMediaMutationResponse = {
  __typename?: "social_media_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<SocialMedia>;
};

/** input type for inserting object relation for remote table "social_media" */
export type SocialMediaObjRelInsertInput = {
  data: SocialMediaInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<SocialMediaOnConflict>;
};

/** on_conflict condition type for table "social_media" */
export type SocialMediaOnConflict = {
  constraint: SocialMediaConstraint;
  update_columns?: Array<SocialMediaUpdateColumn>;
  where?: InputMaybe<SocialMediaBoolExp>;
};

/** Ordering options when selecting data from "social_media". */
export type SocialMediaOrderBy = {
  companies_aggregate?: InputMaybe<CompaniesAggregateOrderBy>;
  created_at?: InputMaybe<OrderBy>;
  facebook_url?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  instagram_url?: InputMaybe<OrderBy>;
  linkedin_url?: InputMaybe<OrderBy>;
  twitter_url?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  youtube_url?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: social_media */
export type SocialMediaPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "social_media" */
export enum SocialMediaSelectColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FACEBOOK_URL = "facebook_url",
  /** column name */
  ID = "id",
  /** column name */
  INSTAGRAM_URL = "instagram_url",
  /** column name */
  LINKEDIN_URL = "linkedin_url",
  /** column name */
  TWITTER_URL = "twitter_url",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  YOUTUBE_URL = "youtube_url",
}

/** input type for updating data in table "social_media" */
export type SocialMediaSetInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  facebook_url?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  instagram_url?: InputMaybe<Scalars["String"]["input"]>;
  linkedin_url?: InputMaybe<Scalars["String"]["input"]>;
  twitter_url?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  youtube_url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type SocialMediaStddevFields = {
  __typename?: "social_media_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type SocialMediaStddevPopFields = {
  __typename?: "social_media_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type SocialMediaStddevSampFields = {
  __typename?: "social_media_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "social_media" */
export type SocialMediaStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: SocialMediaStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type SocialMediaStreamCursorValueInput = {
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  facebook_url?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  instagram_url?: InputMaybe<Scalars["String"]["input"]>;
  linkedin_url?: InputMaybe<Scalars["String"]["input"]>;
  twitter_url?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  youtube_url?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type SocialMediaSumFields = {
  __typename?: "social_media_sum_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "social_media" */
export enum SocialMediaUpdateColumn {
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  FACEBOOK_URL = "facebook_url",
  /** column name */
  ID = "id",
  /** column name */
  INSTAGRAM_URL = "instagram_url",
  /** column name */
  LINKEDIN_URL = "linkedin_url",
  /** column name */
  TWITTER_URL = "twitter_url",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  YOUTUBE_URL = "youtube_url",
}

export type SocialMediaUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<SocialMediaIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<SocialMediaSetInput>;
  /** filter the rows which have to be updated */
  where: SocialMediaBoolExp;
};

/** aggregate var_pop on columns */
export type SocialMediaVarPopFields = {
  __typename?: "social_media_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type SocialMediaVarSampFields = {
  __typename?: "social_media_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type SocialMediaVarianceFields = {
  __typename?: "social_media_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "spider_metrics" */
export type SpiderMetrics = {
  __typename?: "spider_metrics";
  crawl_id: Scalars["uuid"]["output"];
  id: Scalars["bigint"]["output"];
  /** An object relationship */
  metric_definition?: Maybe<MetricDefinitions>;
  metric_id?: Maybe<Scalars["Int"]["output"]>;
  timestamp: Scalars["timestamptz"]["output"];
  value: Scalars["jsonb"]["output"];
};

/** columns and relationships of "spider_metrics" */
export type SpiderMetricsValueArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "spider_metrics" */
export type SpiderMetricsAggregate = {
  __typename?: "spider_metrics_aggregate";
  aggregate?: Maybe<SpiderMetricsAggregateFields>;
  nodes: Array<SpiderMetrics>;
};

export type SpiderMetricsAggregateBoolExp = {
  count?: InputMaybe<SpiderMetricsAggregateBoolExpCount>;
};

export type SpiderMetricsAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<SpiderMetricsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  filter?: InputMaybe<SpiderMetricsBoolExp>;
  predicate: IntComparisonExp;
};

/** aggregate fields of "spider_metrics" */
export type SpiderMetricsAggregateFields = {
  __typename?: "spider_metrics_aggregate_fields";
  avg?: Maybe<SpiderMetricsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<SpiderMetricsMaxFields>;
  min?: Maybe<SpiderMetricsMinFields>;
  stddev?: Maybe<SpiderMetricsStddevFields>;
  stddev_pop?: Maybe<SpiderMetricsStddevPopFields>;
  stddev_samp?: Maybe<SpiderMetricsStddevSampFields>;
  sum?: Maybe<SpiderMetricsSumFields>;
  var_pop?: Maybe<SpiderMetricsVarPopFields>;
  var_samp?: Maybe<SpiderMetricsVarSampFields>;
  variance?: Maybe<SpiderMetricsVarianceFields>;
};

/** aggregate fields of "spider_metrics" */
export type SpiderMetricsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<SpiderMetricsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "spider_metrics" */
export type SpiderMetricsAggregateOrderBy = {
  avg?: InputMaybe<SpiderMetricsAvgOrderBy>;
  count?: InputMaybe<OrderBy>;
  max?: InputMaybe<SpiderMetricsMaxOrderBy>;
  min?: InputMaybe<SpiderMetricsMinOrderBy>;
  stddev?: InputMaybe<SpiderMetricsStddevOrderBy>;
  stddev_pop?: InputMaybe<SpiderMetricsStddevPopOrderBy>;
  stddev_samp?: InputMaybe<SpiderMetricsStddevSampOrderBy>;
  sum?: InputMaybe<SpiderMetricsSumOrderBy>;
  var_pop?: InputMaybe<SpiderMetricsVarPopOrderBy>;
  var_samp?: InputMaybe<SpiderMetricsVarSampOrderBy>;
  variance?: InputMaybe<SpiderMetricsVarianceOrderBy>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type SpiderMetricsAppendInput = {
  value?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** input type for inserting array relation for remote table "spider_metrics" */
export type SpiderMetricsArrRelInsertInput = {
  data: Array<SpiderMetricsInsertInput>;
  /** upsert condition */
  on_conflict?: InputMaybe<SpiderMetricsOnConflict>;
};

/** aggregate avg on columns */
export type SpiderMetricsAvgFields = {
  __typename?: "spider_metrics_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  metric_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by avg() on columns of table "spider_metrics" */
export type SpiderMetricsAvgOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** Boolean expression to filter rows from the table "spider_metrics". All fields are combined with a logical 'AND'. */
export type SpiderMetricsBoolExp = {
  _and?: InputMaybe<Array<SpiderMetricsBoolExp>>;
  _not?: InputMaybe<SpiderMetricsBoolExp>;
  _or?: InputMaybe<Array<SpiderMetricsBoolExp>>;
  crawl_id?: InputMaybe<UuidComparisonExp>;
  id?: InputMaybe<BigintComparisonExp>;
  metric_definition?: InputMaybe<MetricDefinitionsBoolExp>;
  metric_id?: InputMaybe<IntComparisonExp>;
  timestamp?: InputMaybe<TimestamptzComparisonExp>;
  value?: InputMaybe<JsonbComparisonExp>;
};

/** unique or primary key constraints on table "spider_metrics" */
export enum SpiderMetricsConstraint {
  /** unique or primary key constraint on columns "id" */
  SPIDER_METRICS_PKEY = "spider_metrics_pkey",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type SpiderMetricsDeleteAtPathInput = {
  value?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type SpiderMetricsDeleteElemInput = {
  value?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type SpiderMetricsDeleteKeyInput = {
  value?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for incrementing numeric columns in table "spider_metrics" */
export type SpiderMetricsIncInput = {
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  metric_id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "spider_metrics" */
export type SpiderMetricsInsertInput = {
  crawl_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  metric_definition?: InputMaybe<MetricDefinitionsObjRelInsertInput>;
  metric_id?: InputMaybe<Scalars["Int"]["input"]>;
  timestamp?: InputMaybe<Scalars["timestamptz"]["input"]>;
  value?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** aggregate max on columns */
export type SpiderMetricsMaxFields = {
  __typename?: "spider_metrics_max_fields";
  crawl_id?: Maybe<Scalars["uuid"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  metric_id?: Maybe<Scalars["Int"]["output"]>;
  timestamp?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** order by max() on columns of table "spider_metrics" */
export type SpiderMetricsMaxOrderBy = {
  crawl_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
  timestamp?: InputMaybe<OrderBy>;
};

/** aggregate min on columns */
export type SpiderMetricsMinFields = {
  __typename?: "spider_metrics_min_fields";
  crawl_id?: Maybe<Scalars["uuid"]["output"]>;
  id?: Maybe<Scalars["bigint"]["output"]>;
  metric_id?: Maybe<Scalars["Int"]["output"]>;
  timestamp?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** order by min() on columns of table "spider_metrics" */
export type SpiderMetricsMinOrderBy = {
  crawl_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
  timestamp?: InputMaybe<OrderBy>;
};

/** response of any mutation on the table "spider_metrics" */
export type SpiderMetricsMutationResponse = {
  __typename?: "spider_metrics_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<SpiderMetrics>;
};

/** on_conflict condition type for table "spider_metrics" */
export type SpiderMetricsOnConflict = {
  constraint: SpiderMetricsConstraint;
  update_columns?: Array<SpiderMetricsUpdateColumn>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
};

/** Ordering options when selecting data from "spider_metrics". */
export type SpiderMetricsOrderBy = {
  crawl_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  metric_definition?: InputMaybe<MetricDefinitionsOrderBy>;
  metric_id?: InputMaybe<OrderBy>;
  timestamp?: InputMaybe<OrderBy>;
  value?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: spider_metrics */
export type SpiderMetricsPkColumnsInput = {
  id: Scalars["bigint"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type SpiderMetricsPrependInput = {
  value?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "spider_metrics" */
export enum SpiderMetricsSelectColumn {
  /** column name */
  CRAWL_ID = "crawl_id",
  /** column name */
  ID = "id",
  /** column name */
  METRIC_ID = "metric_id",
  /** column name */
  TIMESTAMP = "timestamp",
  /** column name */
  VALUE = "value",
}

/** input type for updating data in table "spider_metrics" */
export type SpiderMetricsSetInput = {
  crawl_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  metric_id?: InputMaybe<Scalars["Int"]["input"]>;
  timestamp?: InputMaybe<Scalars["timestamptz"]["input"]>;
  value?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** aggregate stddev on columns */
export type SpiderMetricsStddevFields = {
  __typename?: "spider_metrics_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  metric_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev() on columns of table "spider_metrics" */
export type SpiderMetricsStddevOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_pop on columns */
export type SpiderMetricsStddevPopFields = {
  __typename?: "spider_metrics_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  metric_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_pop() on columns of table "spider_metrics" */
export type SpiderMetricsStddevPopOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** aggregate stddev_samp on columns */
export type SpiderMetricsStddevSampFields = {
  __typename?: "spider_metrics_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  metric_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by stddev_samp() on columns of table "spider_metrics" */
export type SpiderMetricsStddevSampOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** Streaming cursor of the table "spider_metrics" */
export type SpiderMetricsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: SpiderMetricsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type SpiderMetricsStreamCursorValueInput = {
  crawl_id?: InputMaybe<Scalars["uuid"]["input"]>;
  id?: InputMaybe<Scalars["bigint"]["input"]>;
  metric_id?: InputMaybe<Scalars["Int"]["input"]>;
  timestamp?: InputMaybe<Scalars["timestamptz"]["input"]>;
  value?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** aggregate sum on columns */
export type SpiderMetricsSumFields = {
  __typename?: "spider_metrics_sum_fields";
  id?: Maybe<Scalars["bigint"]["output"]>;
  metric_id?: Maybe<Scalars["Int"]["output"]>;
};

/** order by sum() on columns of table "spider_metrics" */
export type SpiderMetricsSumOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** update columns of table "spider_metrics" */
export enum SpiderMetricsUpdateColumn {
  /** column name */
  CRAWL_ID = "crawl_id",
  /** column name */
  ID = "id",
  /** column name */
  METRIC_ID = "metric_id",
  /** column name */
  TIMESTAMP = "timestamp",
  /** column name */
  VALUE = "value",
}

export type SpiderMetricsUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<SpiderMetricsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<SpiderMetricsDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<SpiderMetricsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<SpiderMetricsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<SpiderMetricsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<SpiderMetricsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<SpiderMetricsSetInput>;
  /** filter the rows which have to be updated */
  where: SpiderMetricsBoolExp;
};

/** aggregate var_pop on columns */
export type SpiderMetricsVarPopFields = {
  __typename?: "spider_metrics_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  metric_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_pop() on columns of table "spider_metrics" */
export type SpiderMetricsVarPopOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** aggregate var_samp on columns */
export type SpiderMetricsVarSampFields = {
  __typename?: "spider_metrics_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  metric_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by var_samp() on columns of table "spider_metrics" */
export type SpiderMetricsVarSampOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** aggregate variance on columns */
export type SpiderMetricsVarianceFields = {
  __typename?: "spider_metrics_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
  metric_id?: Maybe<Scalars["Float"]["output"]>;
};

/** order by variance() on columns of table "spider_metrics" */
export type SpiderMetricsVarianceOrderBy = {
  id?: InputMaybe<OrderBy>;
  metric_id?: InputMaybe<OrderBy>;
};

/** columns and relationships of "strapi_migrations" */
export type StrapiMigrations = {
  __typename?: "strapi_migrations";
  id: Scalars["Int"]["output"];
  name?: Maybe<Scalars["String"]["output"]>;
  time?: Maybe<Scalars["timestamp"]["output"]>;
};

/** aggregated selection of "strapi_migrations" */
export type StrapiMigrationsAggregate = {
  __typename?: "strapi_migrations_aggregate";
  aggregate?: Maybe<StrapiMigrationsAggregateFields>;
  nodes: Array<StrapiMigrations>;
};

/** aggregate fields of "strapi_migrations" */
export type StrapiMigrationsAggregateFields = {
  __typename?: "strapi_migrations_aggregate_fields";
  avg?: Maybe<StrapiMigrationsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<StrapiMigrationsMaxFields>;
  min?: Maybe<StrapiMigrationsMinFields>;
  stddev?: Maybe<StrapiMigrationsStddevFields>;
  stddev_pop?: Maybe<StrapiMigrationsStddevPopFields>;
  stddev_samp?: Maybe<StrapiMigrationsStddevSampFields>;
  sum?: Maybe<StrapiMigrationsSumFields>;
  var_pop?: Maybe<StrapiMigrationsVarPopFields>;
  var_samp?: Maybe<StrapiMigrationsVarSampFields>;
  variance?: Maybe<StrapiMigrationsVarianceFields>;
};

/** aggregate fields of "strapi_migrations" */
export type StrapiMigrationsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<StrapiMigrationsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type StrapiMigrationsAvgFields = {
  __typename?: "strapi_migrations_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "strapi_migrations". All fields are combined with a logical 'AND'. */
export type StrapiMigrationsBoolExp = {
  _and?: InputMaybe<Array<StrapiMigrationsBoolExp>>;
  _not?: InputMaybe<StrapiMigrationsBoolExp>;
  _or?: InputMaybe<Array<StrapiMigrationsBoolExp>>;
  id?: InputMaybe<IntComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  time?: InputMaybe<TimestampComparisonExp>;
};

/** unique or primary key constraints on table "strapi_migrations" */
export enum StrapiMigrationsConstraint {
  /** unique or primary key constraint on columns "id" */
  STRAPI_MIGRATIONS_PKEY = "strapi_migrations_pkey",
}

/** input type for incrementing numeric columns in table "strapi_migrations" */
export type StrapiMigrationsIncInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "strapi_migrations" */
export type StrapiMigrationsInsertInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  time?: InputMaybe<Scalars["timestamp"]["input"]>;
};

/** columns and relationships of "strapi_migrations_internal" */
export type StrapiMigrationsInternal = {
  __typename?: "strapi_migrations_internal";
  id: Scalars["Int"]["output"];
  name?: Maybe<Scalars["String"]["output"]>;
  time?: Maybe<Scalars["timestamp"]["output"]>;
};

/** aggregated selection of "strapi_migrations_internal" */
export type StrapiMigrationsInternalAggregate = {
  __typename?: "strapi_migrations_internal_aggregate";
  aggregate?: Maybe<StrapiMigrationsInternalAggregateFields>;
  nodes: Array<StrapiMigrationsInternal>;
};

/** aggregate fields of "strapi_migrations_internal" */
export type StrapiMigrationsInternalAggregateFields = {
  __typename?: "strapi_migrations_internal_aggregate_fields";
  avg?: Maybe<StrapiMigrationsInternalAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<StrapiMigrationsInternalMaxFields>;
  min?: Maybe<StrapiMigrationsInternalMinFields>;
  stddev?: Maybe<StrapiMigrationsInternalStddevFields>;
  stddev_pop?: Maybe<StrapiMigrationsInternalStddevPopFields>;
  stddev_samp?: Maybe<StrapiMigrationsInternalStddevSampFields>;
  sum?: Maybe<StrapiMigrationsInternalSumFields>;
  var_pop?: Maybe<StrapiMigrationsInternalVarPopFields>;
  var_samp?: Maybe<StrapiMigrationsInternalVarSampFields>;
  variance?: Maybe<StrapiMigrationsInternalVarianceFields>;
};

/** aggregate fields of "strapi_migrations_internal" */
export type StrapiMigrationsInternalAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<StrapiMigrationsInternalSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type StrapiMigrationsInternalAvgFields = {
  __typename?: "strapi_migrations_internal_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "strapi_migrations_internal". All fields are combined with a logical 'AND'. */
export type StrapiMigrationsInternalBoolExp = {
  _and?: InputMaybe<Array<StrapiMigrationsInternalBoolExp>>;
  _not?: InputMaybe<StrapiMigrationsInternalBoolExp>;
  _or?: InputMaybe<Array<StrapiMigrationsInternalBoolExp>>;
  id?: InputMaybe<IntComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  time?: InputMaybe<TimestampComparisonExp>;
};

/** unique or primary key constraints on table "strapi_migrations_internal" */
export enum StrapiMigrationsInternalConstraint {
  /** unique or primary key constraint on columns "id" */
  STRAPI_MIGRATIONS_INTERNAL_PKEY = "strapi_migrations_internal_pkey",
}

/** input type for incrementing numeric columns in table "strapi_migrations_internal" */
export type StrapiMigrationsInternalIncInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "strapi_migrations_internal" */
export type StrapiMigrationsInternalInsertInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  time?: InputMaybe<Scalars["timestamp"]["input"]>;
};

/** aggregate max on columns */
export type StrapiMigrationsInternalMaxFields = {
  __typename?: "strapi_migrations_internal_max_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  time?: Maybe<Scalars["timestamp"]["output"]>;
};

/** aggregate min on columns */
export type StrapiMigrationsInternalMinFields = {
  __typename?: "strapi_migrations_internal_min_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  time?: Maybe<Scalars["timestamp"]["output"]>;
};

/** response of any mutation on the table "strapi_migrations_internal" */
export type StrapiMigrationsInternalMutationResponse = {
  __typename?: "strapi_migrations_internal_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<StrapiMigrationsInternal>;
};

/** on_conflict condition type for table "strapi_migrations_internal" */
export type StrapiMigrationsInternalOnConflict = {
  constraint: StrapiMigrationsInternalConstraint;
  update_columns?: Array<StrapiMigrationsInternalUpdateColumn>;
  where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
};

/** Ordering options when selecting data from "strapi_migrations_internal". */
export type StrapiMigrationsInternalOrderBy = {
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  time?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: strapi_migrations_internal */
export type StrapiMigrationsInternalPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "strapi_migrations_internal" */
export enum StrapiMigrationsInternalSelectColumn {
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
  /** column name */
  TIME = "time",
}

/** input type for updating data in table "strapi_migrations_internal" */
export type StrapiMigrationsInternalSetInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  time?: InputMaybe<Scalars["timestamp"]["input"]>;
};

/** aggregate stddev on columns */
export type StrapiMigrationsInternalStddevFields = {
  __typename?: "strapi_migrations_internal_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type StrapiMigrationsInternalStddevPopFields = {
  __typename?: "strapi_migrations_internal_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type StrapiMigrationsInternalStddevSampFields = {
  __typename?: "strapi_migrations_internal_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "strapi_migrations_internal" */
export type StrapiMigrationsInternalStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: StrapiMigrationsInternalStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type StrapiMigrationsInternalStreamCursorValueInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  time?: InputMaybe<Scalars["timestamp"]["input"]>;
};

/** aggregate sum on columns */
export type StrapiMigrationsInternalSumFields = {
  __typename?: "strapi_migrations_internal_sum_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "strapi_migrations_internal" */
export enum StrapiMigrationsInternalUpdateColumn {
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
  /** column name */
  TIME = "time",
}

export type StrapiMigrationsInternalUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<StrapiMigrationsInternalIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<StrapiMigrationsInternalSetInput>;
  /** filter the rows which have to be updated */
  where: StrapiMigrationsInternalBoolExp;
};

/** aggregate var_pop on columns */
export type StrapiMigrationsInternalVarPopFields = {
  __typename?: "strapi_migrations_internal_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type StrapiMigrationsInternalVarSampFields = {
  __typename?: "strapi_migrations_internal_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type StrapiMigrationsInternalVarianceFields = {
  __typename?: "strapi_migrations_internal_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate max on columns */
export type StrapiMigrationsMaxFields = {
  __typename?: "strapi_migrations_max_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  time?: Maybe<Scalars["timestamp"]["output"]>;
};

/** aggregate min on columns */
export type StrapiMigrationsMinFields = {
  __typename?: "strapi_migrations_min_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  time?: Maybe<Scalars["timestamp"]["output"]>;
};

/** response of any mutation on the table "strapi_migrations" */
export type StrapiMigrationsMutationResponse = {
  __typename?: "strapi_migrations_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<StrapiMigrations>;
};

/** on_conflict condition type for table "strapi_migrations" */
export type StrapiMigrationsOnConflict = {
  constraint: StrapiMigrationsConstraint;
  update_columns?: Array<StrapiMigrationsUpdateColumn>;
  where?: InputMaybe<StrapiMigrationsBoolExp>;
};

/** Ordering options when selecting data from "strapi_migrations". */
export type StrapiMigrationsOrderBy = {
  id?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  time?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: strapi_migrations */
export type StrapiMigrationsPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "strapi_migrations" */
export enum StrapiMigrationsSelectColumn {
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
  /** column name */
  TIME = "time",
}

/** input type for updating data in table "strapi_migrations" */
export type StrapiMigrationsSetInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  time?: InputMaybe<Scalars["timestamp"]["input"]>;
};

/** aggregate stddev on columns */
export type StrapiMigrationsStddevFields = {
  __typename?: "strapi_migrations_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type StrapiMigrationsStddevPopFields = {
  __typename?: "strapi_migrations_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type StrapiMigrationsStddevSampFields = {
  __typename?: "strapi_migrations_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "strapi_migrations" */
export type StrapiMigrationsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: StrapiMigrationsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type StrapiMigrationsStreamCursorValueInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  time?: InputMaybe<Scalars["timestamp"]["input"]>;
};

/** aggregate sum on columns */
export type StrapiMigrationsSumFields = {
  __typename?: "strapi_migrations_sum_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "strapi_migrations" */
export enum StrapiMigrationsUpdateColumn {
  /** column name */
  ID = "id",
  /** column name */
  NAME = "name",
  /** column name */
  TIME = "time",
}

export type StrapiMigrationsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<StrapiMigrationsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<StrapiMigrationsSetInput>;
  /** filter the rows which have to be updated */
  where: StrapiMigrationsBoolExp;
};

/** aggregate var_pop on columns */
export type StrapiMigrationsVarPopFields = {
  __typename?: "strapi_migrations_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type StrapiMigrationsVarSampFields = {
  __typename?: "strapi_migrations_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type StrapiMigrationsVarianceFields = {
  __typename?: "strapi_migrations_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

export type SubscriptionRoot = {
  __typename?: "subscription_root";
  /** An array relationship */
  ad_daily_metrics: Array<AdDailyMetrics>;
  /** An aggregate relationship */
  ad_daily_metrics_aggregate: AdDailyMetricsAggregate;
  /** fetch data from the table: "ad_daily_metrics" using primary key columns */
  ad_daily_metrics_by_pk?: Maybe<AdDailyMetrics>;
  /** fetch data from the table in a streaming manner: "ad_daily_metrics" */
  ad_daily_metrics_stream: Array<AdDailyMetrics>;
  /** fetch data from the table: "ad_packages" */
  ad_packages: Array<AdPackages>;
  /** fetch aggregated fields from the table: "ad_packages" */
  ad_packages_aggregate: AdPackagesAggregate;
  /** fetch data from the table: "ad_packages" using primary key columns */
  ad_packages_by_pk?: Maybe<AdPackages>;
  /** fetch data from the table in a streaming manner: "ad_packages" */
  ad_packages_stream: Array<AdPackages>;
  /** An array relationship */
  ad_variants: Array<AdVariants>;
  /** An aggregate relationship */
  ad_variants_aggregate: AdVariantsAggregate;
  /** fetch data from the table: "ad_variants" using primary key columns */
  ad_variants_by_pk?: Maybe<AdVariants>;
  /** fetch data from the table in a streaming manner: "ad_variants" */
  ad_variants_stream: Array<AdVariants>;
  /** An array relationship */
  addresses: Array<Addresses>;
  /** An aggregate relationship */
  addresses_aggregate: AddressesAggregate;
  /** fetch data from the table: "addresses" using primary key columns */
  addresses_by_pk?: Maybe<Addresses>;
  /** fetch data from the table in a streaming manner: "addresses" */
  addresses_stream: Array<Addresses>;
  /** An array relationship */
  ads: Array<Ads>;
  /** An aggregate relationship */
  ads_aggregate: AdsAggregate;
  /** fetch data from the table: "ads" using primary key columns */
  ads_by_pk?: Maybe<Ads>;
  /** fetch data from the table in a streaming manner: "ads" */
  ads_stream: Array<Ads>;
  /** fetch data from the table: "blacklisted_domains" */
  blacklisted_domains: Array<BlacklistedDomains>;
  /** fetch aggregated fields from the table: "blacklisted_domains" */
  blacklisted_domains_aggregate: BlacklistedDomainsAggregate;
  /** fetch data from the table: "blacklisted_domains" using primary key columns */
  blacklisted_domains_by_pk?: Maybe<BlacklistedDomains>;
  /** fetch data from the table in a streaming manner: "blacklisted_domains" */
  blacklisted_domains_stream: Array<BlacklistedDomains>;
  /** An array relationship */
  blacklisted_urls: Array<BlacklistedUrls>;
  /** An aggregate relationship */
  blacklisted_urls_aggregate: BlacklistedUrlsAggregate;
  /** fetch data from the table: "blacklisted_urls" using primary key columns */
  blacklisted_urls_by_pk?: Maybe<BlacklistedUrls>;
  /** fetch data from the table in a streaming manner: "blacklisted_urls" */
  blacklisted_urls_stream: Array<BlacklistedUrls>;
  /** fetch data from the table: "blocked_ips" */
  blocked_ips: Array<BlockedIps>;
  /** fetch aggregated fields from the table: "blocked_ips" */
  blocked_ips_aggregate: BlockedIpsAggregate;
  /** fetch data from the table: "blocked_ips" using primary key columns */
  blocked_ips_by_pk?: Maybe<BlockedIps>;
  /** fetch data from the table in a streaming manner: "blocked_ips" */
  blocked_ips_stream: Array<BlockedIps>;
  /** An array relationship */
  bookmark_folders: Array<BookmarkFolders>;
  /** An aggregate relationship */
  bookmark_folders_aggregate: BookmarkFoldersAggregate;
  /** fetch data from the table: "bookmark_folders" using primary key columns */
  bookmark_folders_by_pk?: Maybe<BookmarkFolders>;
  /** fetch data from the table in a streaming manner: "bookmark_folders" */
  bookmark_folders_stream: Array<BookmarkFolders>;
  /** An array relationship */
  bookmarks: Array<Bookmarks>;
  /** An aggregate relationship */
  bookmarks_aggregate: BookmarksAggregate;
  /** fetch data from the table: "bookmarks" using primary key columns */
  bookmarks_by_pk?: Maybe<Bookmarks>;
  /** fetch data from the table in a streaming manner: "bookmarks" */
  bookmarks_stream: Array<Bookmarks>;
  /** An array relationship */
  business_domains: Array<BusinessDomains>;
  /** An aggregate relationship */
  business_domains_aggregate: BusinessDomainsAggregate;
  /** fetch data from the table: "business_domains" using primary key columns */
  business_domains_by_pk?: Maybe<BusinessDomains>;
  /** fetch data from the table in a streaming manner: "business_domains" */
  business_domains_stream: Array<BusinessDomains>;
  /** fetch data from the table: "categories" */
  categories: Array<Categories>;
  /** fetch aggregated fields from the table: "categories" */
  categories_aggregate: CategoriesAggregate;
  /** fetch data from the table: "categories" using primary key columns */
  categories_by_pk?: Maybe<Categories>;
  /** fetch data from the table in a streaming manner: "categories" */
  categories_stream: Array<Categories>;
  /** An array relationship */
  categorized_urls: Array<CategorizedUrls>;
  /** An aggregate relationship */
  categorized_urls_aggregate: CategorizedUrlsAggregate;
  /** fetch data from the table: "categorized_urls" using primary key columns */
  categorized_urls_by_pk?: Maybe<CategorizedUrls>;
  /** fetch data from the table in a streaming manner: "categorized_urls" */
  categorized_urls_stream: Array<CategorizedUrls>;
  /** fetch data from the table: "circuit_breaker_states" */
  circuit_breaker_states: Array<CircuitBreakerStates>;
  /** fetch aggregated fields from the table: "circuit_breaker_states" */
  circuit_breaker_states_aggregate: CircuitBreakerStatesAggregate;
  /** fetch data from the table: "circuit_breaker_states" using primary key columns */
  circuit_breaker_states_by_pk?: Maybe<CircuitBreakerStates>;
  /** fetch data from the table in a streaming manner: "circuit_breaker_states" */
  circuit_breaker_states_stream: Array<CircuitBreakerStates>;
  /** An array relationship */
  cities: Array<Cities>;
  /** An aggregate relationship */
  cities_aggregate: CitiesAggregate;
  /** fetch data from the table: "cities" using primary key columns */
  cities_by_pk?: Maybe<Cities>;
  /** fetch data from the table in a streaming manner: "cities" */
  cities_stream: Array<Cities>;
  /** An array relationship */
  comments: Array<Comments>;
  /** An aggregate relationship */
  comments_aggregate: CommentsAggregate;
  /** fetch data from the table: "comments" using primary key columns */
  comments_by_pk?: Maybe<Comments>;
  /** fetch data from the table in a streaming manner: "comments" */
  comments_stream: Array<Comments>;
  /** An array relationship */
  companies: Array<Companies>;
  /** An aggregate relationship */
  companies_aggregate: CompaniesAggregate;
  /** fetch data from the table: "companies" using primary key columns */
  companies_by_pk?: Maybe<Companies>;
  /** fetch data from the table in a streaming manner: "companies" */
  companies_stream: Array<Companies>;
  /** An array relationship */
  company_contacts: Array<CompanyContacts>;
  /** An aggregate relationship */
  company_contacts_aggregate: CompanyContactsAggregate;
  /** fetch data from the table: "company_contacts" using primary key columns */
  company_contacts_by_pk?: Maybe<CompanyContacts>;
  /** fetch data from the table in a streaming manner: "company_contacts" */
  company_contacts_stream: Array<CompanyContacts>;
  /** An array relationship */
  company_employees: Array<CompanyEmployees>;
  /** An aggregate relationship */
  company_employees_aggregate: CompanyEmployeesAggregate;
  /** fetch data from the table: "company_employees" using primary key columns */
  company_employees_by_pk?: Maybe<CompanyEmployees>;
  /** fetch data from the table in a streaming manner: "company_employees" */
  company_employees_stream: Array<CompanyEmployees>;
  /** An array relationship */
  company_extras: Array<CompanyExtras>;
  /** An aggregate relationship */
  company_extras_aggregate: CompanyExtrasAggregate;
  /** fetch data from the table: "company_extras" using primary key columns */
  company_extras_by_pk?: Maybe<CompanyExtras>;
  /** fetch data from the table in a streaming manner: "company_extras" */
  company_extras_stream: Array<CompanyExtras>;
  /** An array relationship */
  company_metrics: Array<CompanyMetrics>;
  /** An aggregate relationship */
  company_metrics_aggregate: CompanyMetricsAggregate;
  /** fetch data from the table: "company_metrics" using primary key columns */
  company_metrics_by_pk?: Maybe<CompanyMetrics>;
  /** fetch data from the table in a streaming manner: "company_metrics" */
  company_metrics_stream: Array<CompanyMetrics>;
  /** An array relationship */
  contacts: Array<Contacts>;
  /** An aggregate relationship */
  contacts_aggregate: ContactsAggregate;
  /** fetch data from the table: "contacts" using primary key columns */
  contacts_by_pk?: Maybe<Contacts>;
  /** fetch data from the table in a streaming manner: "contacts" */
  contacts_stream: Array<Contacts>;
  /** An array relationship */
  content_categories: Array<ContentCategories>;
  /** An aggregate relationship */
  content_categories_aggregate: ContentCategoriesAggregate;
  /** fetch data from the table: "content_categories" using primary key columns */
  content_categories_by_pk?: Maybe<ContentCategories>;
  /** fetch data from the table in a streaming manner: "content_categories" */
  content_categories_stream: Array<ContentCategories>;
  /** fetch data from the table: "content_scores" */
  content_scores: Array<ContentScores>;
  /** fetch aggregated fields from the table: "content_scores" */
  content_scores_aggregate: ContentScoresAggregate;
  /** fetch data from the table in a streaming manner: "content_scores" */
  content_scores_stream: Array<ContentScores>;
  /** An array relationship */
  content_source_visits: Array<ContentSourceVisits>;
  /** An aggregate relationship */
  content_source_visits_aggregate: ContentSourceVisitsAggregate;
  /** fetch data from the table: "content_source_visits" using primary key columns */
  content_source_visits_by_pk?: Maybe<ContentSourceVisits>;
  /** fetch data from the table in a streaming manner: "content_source_visits" */
  content_source_visits_stream: Array<ContentSourceVisits>;
  /** An array relationship */
  content_sources: Array<ContentSources>;
  /** An aggregate relationship */
  content_sources_aggregate: ContentSourcesAggregate;
  /** fetch data from the table: "content_sources" using primary key columns */
  content_sources_by_pk?: Maybe<ContentSources>;
  /** fetch data from the table in a streaming manner: "content_sources" */
  content_sources_stream: Array<ContentSources>;
  /** An array relationship */
  content_statuses: Array<ContentStatuses>;
  /** An aggregate relationship */
  content_statuses_aggregate: ContentStatusesAggregate;
  /** fetch data from the table: "content_statuses" using primary key columns */
  content_statuses_by_pk?: Maybe<ContentStatuses>;
  /** fetch data from the table in a streaming manner: "content_statuses" */
  content_statuses_stream: Array<ContentStatuses>;
  /** An array relationship */
  content_tags: Array<ContentTags>;
  /** An aggregate relationship */
  content_tags_aggregate: ContentTagsAggregate;
  /** fetch data from the table: "content_tags" using primary key columns */
  content_tags_by_pk?: Maybe<ContentTags>;
  /** fetch data from the table in a streaming manner: "content_tags" */
  content_tags_stream: Array<ContentTags>;
  /** fetch data from the table: "contents" */
  contents: Array<Contents>;
  /** fetch aggregated fields from the table: "contents" */
  contents_aggregate: ContentsAggregate;
  /** fetch data from the table: "contents" using primary key columns */
  contents_by_pk?: Maybe<Contents>;
  /** fetch data from the table in a streaming manner: "contents" */
  contents_stream: Array<Contents>;
  /** fetch data from the table: "countries" */
  countries: Array<Countries>;
  /** fetch aggregated fields from the table: "countries" */
  countries_aggregate: CountriesAggregate;
  /** fetch data from the table: "countries" using primary key columns */
  countries_by_pk?: Maybe<Countries>;
  /** fetch data from the table in a streaming manner: "countries" */
  countries_stream: Array<Countries>;
  /** An array relationship */
  customer_payments: Array<CustomerPayments>;
  /** An aggregate relationship */
  customer_payments_aggregate: CustomerPaymentsAggregate;
  /** fetch data from the table: "customer_payments" using primary key columns */
  customer_payments_by_pk?: Maybe<CustomerPayments>;
  /** fetch data from the table in a streaming manner: "customer_payments" */
  customer_payments_stream: Array<CustomerPayments>;
  /** fetch data from the table: "customer_processed_webhooks" */
  customer_processed_webhooks: Array<CustomerProcessedWebhooks>;
  /** fetch aggregated fields from the table: "customer_processed_webhooks" */
  customer_processed_webhooks_aggregate: CustomerProcessedWebhooksAggregate;
  /** fetch data from the table: "customer_processed_webhooks" using primary key columns */
  customer_processed_webhooks_by_pk?: Maybe<CustomerProcessedWebhooks>;
  /** fetch data from the table in a streaming manner: "customer_processed_webhooks" */
  customer_processed_webhooks_stream: Array<CustomerProcessedWebhooks>;
  /** An array relationship */
  customer_refunds: Array<CustomerRefunds>;
  /** An aggregate relationship */
  customer_refunds_aggregate: CustomerRefundsAggregate;
  /** fetch data from the table: "customer_refunds" using primary key columns */
  customer_refunds_by_pk?: Maybe<CustomerRefunds>;
  /** fetch data from the table in a streaming manner: "customer_refunds" */
  customer_refunds_stream: Array<CustomerRefunds>;
  /** fetch data from the table: "customer_subscription_plans" */
  customer_subscription_plans: Array<CustomerSubscriptionPlans>;
  /** fetch aggregated fields from the table: "customer_subscription_plans" */
  customer_subscription_plans_aggregate: CustomerSubscriptionPlansAggregate;
  /** fetch data from the table: "customer_subscription_plans" using primary key columns */
  customer_subscription_plans_by_pk?: Maybe<CustomerSubscriptionPlans>;
  /** fetch data from the table in a streaming manner: "customer_subscription_plans" */
  customer_subscription_plans_stream: Array<CustomerSubscriptionPlans>;
  /** An array relationship */
  customer_subscriptions: Array<CustomerSubscriptions>;
  /** An aggregate relationship */
  customer_subscriptions_aggregate: CustomerSubscriptionsAggregate;
  /** fetch data from the table: "customer_subscriptions" using primary key columns */
  customer_subscriptions_by_pk?: Maybe<CustomerSubscriptions>;
  /** fetch data from the table in a streaming manner: "customer_subscriptions" */
  customer_subscriptions_stream: Array<CustomerSubscriptions>;
  /** fetch data from the table: "embedding_reviews" */
  embedding_reviews: Array<EmbeddingReviews>;
  /** fetch aggregated fields from the table: "embedding_reviews" */
  embedding_reviews_aggregate: EmbeddingReviewsAggregate;
  /** fetch data from the table: "embedding_reviews" using primary key columns */
  embedding_reviews_by_pk?: Maybe<EmbeddingReviews>;
  /** fetch data from the table in a streaming manner: "embedding_reviews" */
  embedding_reviews_stream: Array<EmbeddingReviews>;
  /** fetch data from the table: "error_correlations" */
  error_correlations: Array<ErrorCorrelations>;
  /** fetch aggregated fields from the table: "error_correlations" */
  error_correlations_aggregate: ErrorCorrelationsAggregate;
  /** fetch data from the table in a streaming manner: "error_correlations" */
  error_correlations_stream: Array<ErrorCorrelations>;
  /** fetch data from the table: "error_frequency" */
  error_frequency: Array<ErrorFrequency>;
  /** fetch aggregated fields from the table: "error_frequency" */
  error_frequency_aggregate: ErrorFrequencyAggregate;
  /** fetch data from the table in a streaming manner: "error_frequency" */
  error_frequency_stream: Array<ErrorFrequency>;
  /** fetch data from the table: "error_logs" */
  error_logs: Array<ErrorLogs>;
  /** fetch aggregated fields from the table: "error_logs" */
  error_logs_aggregate: ErrorLogsAggregate;
  /** fetch data from the table: "error_logs" using primary key columns */
  error_logs_by_pk?: Maybe<ErrorLogs>;
  /** fetch data from the table in a streaming manner: "error_logs" */
  error_logs_stream: Array<ErrorLogs>;
  /** fetch data from the table: "error_metrics" */
  error_metrics: Array<ErrorMetrics>;
  /** fetch aggregated fields from the table: "error_metrics" */
  error_metrics_aggregate: ErrorMetricsAggregate;
  /** fetch data from the table in a streaming manner: "error_metrics" */
  error_metrics_stream: Array<ErrorMetrics>;
  /** fetch data from the table: "error_patterns" */
  error_patterns: Array<ErrorPatterns>;
  /** fetch aggregated fields from the table: "error_patterns" */
  error_patterns_aggregate: ErrorPatternsAggregate;
  /** fetch data from the table in a streaming manner: "error_patterns" */
  error_patterns_stream: Array<ErrorPatterns>;
  /** fetch data from the table: "error_stats" */
  error_stats: Array<ErrorStats>;
  /** fetch aggregated fields from the table: "error_stats" */
  error_stats_aggregate: ErrorStatsAggregate;
  /** fetch data from the table in a streaming manner: "error_stats" */
  error_stats_stream: Array<ErrorStats>;
  /** fetch data from the table: "feature_requests" */
  feature_requests: Array<FeatureRequests>;
  /** fetch aggregated fields from the table: "feature_requests" */
  feature_requests_aggregate: FeatureRequestsAggregate;
  /** fetch data from the table: "feature_requests" using primary key columns */
  feature_requests_by_pk?: Maybe<FeatureRequests>;
  /** fetch data from the table in a streaming manner: "feature_requests" */
  feature_requests_stream: Array<FeatureRequests>;
  /** An array relationship */
  feature_votes: Array<FeatureVotes>;
  /** An aggregate relationship */
  feature_votes_aggregate: FeatureVotesAggregate;
  /** fetch data from the table: "feature_votes" using primary key columns */
  feature_votes_by_pk?: Maybe<FeatureVotes>;
  /** fetch data from the table in a streaming manner: "feature_votes" */
  feature_votes_stream: Array<FeatureVotes>;
  /** An array relationship */
  feed_categories: Array<FeedCategories>;
  /** An aggregate relationship */
  feed_categories_aggregate: FeedCategoriesAggregate;
  /** fetch data from the table: "feed_categories" using primary key columns */
  feed_categories_by_pk?: Maybe<FeedCategories>;
  /** fetch data from the table in a streaming manner: "feed_categories" */
  feed_categories_stream: Array<FeedCategories>;
  /** An array relationship */
  feed_sources: Array<FeedSources>;
  /** An aggregate relationship */
  feed_sources_aggregate: FeedSourcesAggregate;
  /** fetch data from the table: "feed_sources" using primary key columns */
  feed_sources_by_pk?: Maybe<FeedSources>;
  /** fetch data from the table in a streaming manner: "feed_sources" */
  feed_sources_stream: Array<FeedSources>;
  /** An array relationship */
  feedbacks: Array<Feedbacks>;
  /** An aggregate relationship */
  feedbacks_aggregate: FeedbacksAggregate;
  /** fetch data from the table: "feedbacks" using primary key columns */
  feedbacks_by_pk?: Maybe<Feedbacks>;
  /** fetch data from the table in a streaming manner: "feedbacks" */
  feedbacks_stream: Array<Feedbacks>;
  /** An array relationship */
  feeds: Array<Feeds>;
  /** An aggregate relationship */
  feeds_aggregate: FeedsAggregate;
  /** fetch data from the table: "feeds" using primary key columns */
  feeds_by_pk?: Maybe<Feeds>;
  /** fetch data from the table in a streaming manner: "feeds" */
  feeds_stream: Array<Feeds>;
  /** An array relationship */
  follows: Array<Follows>;
  /** An aggregate relationship */
  follows_aggregate: FollowsAggregate;
  /** fetch data from the table: "follows" using primary key columns */
  follows_by_pk?: Maybe<Follows>;
  /** fetch data from the table in a streaming manner: "follows" */
  follows_stream: Array<Follows>;
  /** fetch data from the table: "metric_definitions" */
  metric_definitions: Array<MetricDefinitions>;
  /** fetch aggregated fields from the table: "metric_definitions" */
  metric_definitions_aggregate: MetricDefinitionsAggregate;
  /** fetch data from the table: "metric_definitions" using primary key columns */
  metric_definitions_by_pk?: Maybe<MetricDefinitions>;
  /** fetch data from the table in a streaming manner: "metric_definitions" */
  metric_definitions_stream: Array<MetricDefinitions>;
  /** An array relationship */
  news: Array<News>;
  /** An aggregate relationship */
  news_aggregate: NewsAggregate;
  /** fetch data from the table: "news" using primary key columns */
  news_by_pk?: Maybe<News>;
  /** fetch data from the table: "news_details" */
  news_details: Array<NewsDetails>;
  /** fetch aggregated fields from the table: "news_details" */
  news_details_aggregate: NewsDetailsAggregate;
  /** fetch data from the table in a streaming manner: "news_details" */
  news_details_stream: Array<NewsDetails>;
  /** fetch data from the table in a streaming manner: "news" */
  news_stream: Array<News>;
  /** An array relationship */
  news_summaries: Array<NewsSummaries>;
  /** An aggregate relationship */
  news_summaries_aggregate: NewsSummariesAggregate;
  /** fetch data from the table: "news_summaries" using primary key columns */
  news_summaries_by_pk?: Maybe<NewsSummaries>;
  /** fetch data from the table in a streaming manner: "news_summaries" */
  news_summaries_stream: Array<NewsSummaries>;
  /** An array relationship */
  news_tags: Array<NewsTags>;
  /** An aggregate relationship */
  news_tags_aggregate: NewsTagsAggregate;
  /** fetch data from the table: "news_tags" using primary key columns */
  news_tags_by_pk?: Maybe<NewsTags>;
  /** fetch data from the table in a streaming manner: "news_tags" */
  news_tags_stream: Array<NewsTags>;
  /** fetch data from the table: "newsletters" */
  newsletters: Array<Newsletters>;
  /** fetch aggregated fields from the table: "newsletters" */
  newsletters_aggregate: NewslettersAggregate;
  /** fetch data from the table: "newsletters" using primary key columns */
  newsletters_by_pk?: Maybe<Newsletters>;
  /** fetch data from the table in a streaming manner: "newsletters" */
  newsletters_stream: Array<Newsletters>;
  /** fetch data from the table: "payment_providers" */
  payment_providers: Array<PaymentProviders>;
  /** fetch aggregated fields from the table: "payment_providers" */
  payment_providers_aggregate: PaymentProvidersAggregate;
  /** fetch data from the table: "payment_providers" using primary key columns */
  payment_providers_by_pk?: Maybe<PaymentProviders>;
  /** fetch data from the table in a streaming manner: "payment_providers" */
  payment_providers_stream: Array<PaymentProviders>;
  /** fetch data from the table: "plan_permissions" */
  plan_permissions: Array<PlanPermissions>;
  /** fetch aggregated fields from the table: "plan_permissions" */
  plan_permissions_aggregate: PlanPermissionsAggregate;
  /** fetch data from the table: "plan_permissions" using primary key columns */
  plan_permissions_by_pk?: Maybe<PlanPermissions>;
  /** fetch data from the table in a streaming manner: "plan_permissions" */
  plan_permissions_stream: Array<PlanPermissions>;
  /** fetch data from the table: "recent_errors" */
  recent_errors: Array<RecentErrors>;
  /** fetch aggregated fields from the table: "recent_errors" */
  recent_errors_aggregate: RecentErrorsAggregate;
  /** fetch data from the table in a streaming manner: "recent_errors" */
  recent_errors_stream: Array<RecentErrors>;
  /** fetch data from the table: "referral_stats" */
  referral_stats: Array<ReferralStats>;
  /** fetch aggregated fields from the table: "referral_stats" */
  referral_stats_aggregate: ReferralStatsAggregate;
  /** fetch data from the table in a streaming manner: "referral_stats" */
  referral_stats_stream: Array<ReferralStats>;
  /** fetch data from the table: "referrals" */
  referrals: Array<Referrals>;
  /** fetch aggregated fields from the table: "referrals" */
  referrals_aggregate: ReferralsAggregate;
  /** fetch data from the table: "referrals" using primary key columns */
  referrals_by_pk?: Maybe<Referrals>;
  /** fetch data from the table in a streaming manner: "referrals" */
  referrals_stream: Array<Referrals>;
  /** fetch data from the table: "referrer_blocks" */
  referrer_blocks: Array<ReferrerBlocks>;
  /** fetch aggregated fields from the table: "referrer_blocks" */
  referrer_blocks_aggregate: ReferrerBlocksAggregate;
  /** fetch data from the table: "referrer_blocks" using primary key columns */
  referrer_blocks_by_pk?: Maybe<ReferrerBlocks>;
  /** fetch data from the table in a streaming manner: "referrer_blocks" */
  referrer_blocks_stream: Array<ReferrerBlocks>;
  /** fetch data from the table: "referrer_risk_metrics" */
  referrer_risk_metrics: Array<ReferrerRiskMetrics>;
  /** fetch aggregated fields from the table: "referrer_risk_metrics" */
  referrer_risk_metrics_aggregate: ReferrerRiskMetricsAggregate;
  /** fetch data from the table in a streaming manner: "referrer_risk_metrics" */
  referrer_risk_metrics_stream: Array<ReferrerRiskMetrics>;
  /** fetch data from the table: "research" */
  research: Array<Research>;
  /** fetch aggregated fields from the table: "research" */
  research_aggregate: ResearchAggregate;
  /** fetch data from the table: "research" using primary key columns */
  research_by_pk?: Maybe<Research>;
  /** An array relationship */
  research_embeddings: Array<ResearchEmbeddings>;
  /** An aggregate relationship */
  research_embeddings_aggregate: ResearchEmbeddingsAggregate;
  /** fetch data from the table: "research_embeddings" using primary key columns */
  research_embeddings_by_pk?: Maybe<ResearchEmbeddings>;
  /** fetch data from the table in a streaming manner: "research_embeddings" */
  research_embeddings_stream: Array<ResearchEmbeddings>;
  /** fetch data from the table in a streaming manner: "research" */
  research_stream: Array<Research>;
  /** An array relationship */
  responses: Array<Responses>;
  /** An aggregate relationship */
  responses_aggregate: ResponsesAggregate;
  /** fetch data from the table: "responses" using primary key columns */
  responses_by_pk?: Maybe<Responses>;
  /** fetch data from the table in a streaming manner: "responses" */
  responses_stream: Array<Responses>;
  /** fetch data from the table: "role_hierarchy" */
  role_hierarchy: Array<RoleHierarchy>;
  /** fetch aggregated fields from the table: "role_hierarchy" */
  role_hierarchy_aggregate: RoleHierarchyAggregate;
  /** fetch data from the table: "role_hierarchy" using primary key columns */
  role_hierarchy_by_pk?: Maybe<RoleHierarchy>;
  /** fetch data from the table in a streaming manner: "role_hierarchy" */
  role_hierarchy_stream: Array<RoleHierarchy>;
  /** fetch data from the table: "role_permissions" */
  role_permissions: Array<RolePermissions>;
  /** fetch aggregated fields from the table: "role_permissions" */
  role_permissions_aggregate: RolePermissionsAggregate;
  /** fetch data from the table: "role_permissions" using primary key columns */
  role_permissions_by_pk?: Maybe<RolePermissions>;
  /** fetch data from the table: "role_permissions_materialized" */
  role_permissions_materialized: Array<RolePermissionsMaterialized>;
  /** fetch aggregated fields from the table: "role_permissions_materialized" */
  role_permissions_materialized_aggregate: RolePermissionsMaterializedAggregate;
  /** fetch data from the table: "role_permissions_materialized" using primary key columns */
  role_permissions_materialized_by_pk?: Maybe<RolePermissionsMaterialized>;
  /** fetch data from the table in a streaming manner: "role_permissions_materialized" */
  role_permissions_materialized_stream: Array<RolePermissionsMaterialized>;
  /** fetch data from the table in a streaming manner: "role_permissions" */
  role_permissions_stream: Array<RolePermissions>;
  /** fetch data from the table: "scoring_weights" */
  scoring_weights: Array<ScoringWeights>;
  /** fetch aggregated fields from the table: "scoring_weights" */
  scoring_weights_aggregate: ScoringWeightsAggregate;
  /** fetch data from the table: "scoring_weights" using primary key columns */
  scoring_weights_by_pk?: Maybe<ScoringWeights>;
  /** fetch data from the table in a streaming manner: "scoring_weights" */
  scoring_weights_stream: Array<ScoringWeights>;
  /** fetch data from the table: "searches" */
  searches: Array<Searches>;
  /** fetch aggregated fields from the table: "searches" */
  searches_aggregate: SearchesAggregate;
  /** fetch data from the table: "searches" using primary key columns */
  searches_by_pk?: Maybe<Searches>;
  /** fetch data from the table in a streaming manner: "searches" */
  searches_stream: Array<Searches>;
  /** fetch data from the table: "security_metrics" */
  security_metrics: Array<SecurityMetrics>;
  /** fetch aggregated fields from the table: "security_metrics" */
  security_metrics_aggregate: SecurityMetricsAggregate;
  /** fetch data from the table in a streaming manner: "security_metrics" */
  security_metrics_stream: Array<SecurityMetrics>;
  /** fetch data from the table: "slow_query_patterns" */
  slow_query_patterns: Array<SlowQueryPatterns>;
  /** fetch aggregated fields from the table: "slow_query_patterns" */
  slow_query_patterns_aggregate: SlowQueryPatternsAggregate;
  /** fetch data from the table in a streaming manner: "slow_query_patterns" */
  slow_query_patterns_stream: Array<SlowQueryPatterns>;
  /** fetch data from the table: "social_media" */
  social_media: Array<SocialMedia>;
  /** fetch aggregated fields from the table: "social_media" */
  social_media_aggregate: SocialMediaAggregate;
  /** fetch data from the table: "social_media" using primary key columns */
  social_media_by_pk?: Maybe<SocialMedia>;
  /** fetch data from the table in a streaming manner: "social_media" */
  social_media_stream: Array<SocialMedia>;
  /** An array relationship */
  spider_metrics: Array<SpiderMetrics>;
  /** An aggregate relationship */
  spider_metrics_aggregate: SpiderMetricsAggregate;
  /** fetch data from the table: "spider_metrics" using primary key columns */
  spider_metrics_by_pk?: Maybe<SpiderMetrics>;
  /** fetch data from the table in a streaming manner: "spider_metrics" */
  spider_metrics_stream: Array<SpiderMetrics>;
  /** fetch data from the table: "strapi_migrations" */
  strapi_migrations: Array<StrapiMigrations>;
  /** fetch aggregated fields from the table: "strapi_migrations" */
  strapi_migrations_aggregate: StrapiMigrationsAggregate;
  /** fetch data from the table: "strapi_migrations" using primary key columns */
  strapi_migrations_by_pk?: Maybe<StrapiMigrations>;
  /** fetch data from the table: "strapi_migrations_internal" */
  strapi_migrations_internal: Array<StrapiMigrationsInternal>;
  /** fetch aggregated fields from the table: "strapi_migrations_internal" */
  strapi_migrations_internal_aggregate: StrapiMigrationsInternalAggregate;
  /** fetch data from the table: "strapi_migrations_internal" using primary key columns */
  strapi_migrations_internal_by_pk?: Maybe<StrapiMigrationsInternal>;
  /** fetch data from the table in a streaming manner: "strapi_migrations_internal" */
  strapi_migrations_internal_stream: Array<StrapiMigrationsInternal>;
  /** fetch data from the table in a streaming manner: "strapi_migrations" */
  strapi_migrations_stream: Array<StrapiMigrations>;
  /** fetch data from the table: "table_maintenance_log" */
  table_maintenance_log: Array<TableMaintenanceLog>;
  /** fetch aggregated fields from the table: "table_maintenance_log" */
  table_maintenance_log_aggregate: TableMaintenanceLogAggregate;
  /** fetch data from the table: "table_maintenance_log" using primary key columns */
  table_maintenance_log_by_pk?: Maybe<TableMaintenanceLog>;
  /** fetch data from the table in a streaming manner: "table_maintenance_log" */
  table_maintenance_log_stream: Array<TableMaintenanceLog>;
  /** fetch data from the table: "table_query_performance" */
  table_query_performance: Array<TableQueryPerformance>;
  /** fetch aggregated fields from the table: "table_query_performance" */
  table_query_performance_aggregate: TableQueryPerformanceAggregate;
  /** fetch data from the table in a streaming manner: "table_query_performance" */
  table_query_performance_stream: Array<TableQueryPerformance>;
  /** fetch data from the table: "table_sequence_usage" */
  table_sequence_usage: Array<TableSequenceUsage>;
  /** fetch aggregated fields from the table: "table_sequence_usage" */
  table_sequence_usage_aggregate: TableSequenceUsageAggregate;
  /** fetch data from the table in a streaming manner: "table_sequence_usage" */
  table_sequence_usage_stream: Array<TableSequenceUsage>;
  /** fetch data from the table: "table_statistics" */
  table_statistics: Array<TableStatistics>;
  /** fetch aggregated fields from the table: "table_statistics" */
  table_statistics_aggregate: TableStatisticsAggregate;
  /** fetch data from the table: "table_statistics" using primary key columns */
  table_statistics_by_pk?: Maybe<TableStatistics>;
  /** fetch data from the table in a streaming manner: "table_statistics" */
  table_statistics_stream: Array<TableStatistics>;
  /** fetch data from the table: "tags" */
  tags: Array<Tags>;
  /** fetch aggregated fields from the table: "tags" */
  tags_aggregate: TagsAggregate;
  /** fetch data from the table: "tags" using primary key columns */
  tags_by_pk?: Maybe<Tags>;
  /** fetch data from the table in a streaming manner: "tags" */
  tags_stream: Array<Tags>;
  /** fetch data from the table: "user_metrics" */
  user_metrics: Array<UserMetrics>;
  /** fetch aggregated fields from the table: "user_metrics" */
  user_metrics_aggregate: UserMetricsAggregate;
  /** fetch data from the table: "user_metrics" using primary key columns */
  user_metrics_by_pk?: Maybe<UserMetrics>;
  /** fetch data from the table in a streaming manner: "user_metrics" */
  user_metrics_stream: Array<UserMetrics>;
  /** fetch data from the table: "user_profiles" */
  user_profiles: Array<UserProfiles>;
  /** fetch aggregated fields from the table: "user_profiles" */
  user_profiles_aggregate: UserProfilesAggregate;
  /** fetch data from the table: "user_profiles" using primary key columns */
  user_profiles_by_pk?: Maybe<UserProfiles>;
  /** fetch data from the table in a streaming manner: "user_profiles" */
  user_profiles_stream: Array<UserProfiles>;
  /** fetch data from the table: "votes" */
  votes: Array<Votes>;
  /** fetch aggregated fields from the table: "votes" */
  votes_aggregate: VotesAggregate;
  /** fetch data from the table: "votes" using primary key columns */
  votes_by_pk?: Maybe<Votes>;
  /** fetch data from the table in a streaming manner: "votes" */
  votes_stream: Array<Votes>;
  /** fetch data from the table: "workflows" */
  workflows: Array<Workflows>;
  /** fetch aggregated fields from the table: "workflows" */
  workflows_aggregate: WorkflowsAggregate;
  /** fetch data from the table: "workflows" using primary key columns */
  workflows_by_pk?: Maybe<Workflows>;
  /** fetch data from the table in a streaming manner: "workflows" */
  workflows_stream: Array<Workflows>;
};

export type SubscriptionRootAdDailyMetricsArgs = {
  distinct_on?: InputMaybe<Array<AdDailyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdDailyMetricsOrderBy>>;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
};

export type SubscriptionRootAdDailyMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<AdDailyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdDailyMetricsOrderBy>>;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
};

export type SubscriptionRootAdDailyMetricsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootAdDailyMetricsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<AdDailyMetricsStreamCursorInput>>;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
};

export type SubscriptionRootAdPackagesArgs = {
  distinct_on?: InputMaybe<Array<AdPackagesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdPackagesOrderBy>>;
  where?: InputMaybe<AdPackagesBoolExp>;
};

export type SubscriptionRootAdPackagesAggregateArgs = {
  distinct_on?: InputMaybe<Array<AdPackagesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdPackagesOrderBy>>;
  where?: InputMaybe<AdPackagesBoolExp>;
};

export type SubscriptionRootAdPackagesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootAdPackagesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<AdPackagesStreamCursorInput>>;
  where?: InputMaybe<AdPackagesBoolExp>;
};

export type SubscriptionRootAdVariantsArgs = {
  distinct_on?: InputMaybe<Array<AdVariantsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdVariantsOrderBy>>;
  where?: InputMaybe<AdVariantsBoolExp>;
};

export type SubscriptionRootAdVariantsAggregateArgs = {
  distinct_on?: InputMaybe<Array<AdVariantsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdVariantsOrderBy>>;
  where?: InputMaybe<AdVariantsBoolExp>;
};

export type SubscriptionRootAdVariantsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootAdVariantsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<AdVariantsStreamCursorInput>>;
  where?: InputMaybe<AdVariantsBoolExp>;
};

export type SubscriptionRootAddressesArgs = {
  distinct_on?: InputMaybe<Array<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

export type SubscriptionRootAddressesAggregateArgs = {
  distinct_on?: InputMaybe<Array<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

export type SubscriptionRootAddressesByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootAddressesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<AddressesStreamCursorInput>>;
  where?: InputMaybe<AddressesBoolExp>;
};

export type SubscriptionRootAdsArgs = {
  distinct_on?: InputMaybe<Array<AdsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdsOrderBy>>;
  where?: InputMaybe<AdsBoolExp>;
};

export type SubscriptionRootAdsAggregateArgs = {
  distinct_on?: InputMaybe<Array<AdsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdsOrderBy>>;
  where?: InputMaybe<AdsBoolExp>;
};

export type SubscriptionRootAdsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootAdsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<AdsStreamCursorInput>>;
  where?: InputMaybe<AdsBoolExp>;
};

export type SubscriptionRootBlacklistedDomainsArgs = {
  distinct_on?: InputMaybe<Array<BlacklistedDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlacklistedDomainsOrderBy>>;
  where?: InputMaybe<BlacklistedDomainsBoolExp>;
};

export type SubscriptionRootBlacklistedDomainsAggregateArgs = {
  distinct_on?: InputMaybe<Array<BlacklistedDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlacklistedDomainsOrderBy>>;
  where?: InputMaybe<BlacklistedDomainsBoolExp>;
};

export type SubscriptionRootBlacklistedDomainsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootBlacklistedDomainsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<BlacklistedDomainsStreamCursorInput>>;
  where?: InputMaybe<BlacklistedDomainsBoolExp>;
};

export type SubscriptionRootBlacklistedUrlsArgs = {
  distinct_on?: InputMaybe<Array<BlacklistedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlacklistedUrlsOrderBy>>;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
};

export type SubscriptionRootBlacklistedUrlsAggregateArgs = {
  distinct_on?: InputMaybe<Array<BlacklistedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlacklistedUrlsOrderBy>>;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
};

export type SubscriptionRootBlacklistedUrlsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootBlacklistedUrlsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<BlacklistedUrlsStreamCursorInput>>;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
};

export type SubscriptionRootBlockedIpsArgs = {
  distinct_on?: InputMaybe<Array<BlockedIpsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlockedIpsOrderBy>>;
  where?: InputMaybe<BlockedIpsBoolExp>;
};

export type SubscriptionRootBlockedIpsAggregateArgs = {
  distinct_on?: InputMaybe<Array<BlockedIpsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlockedIpsOrderBy>>;
  where?: InputMaybe<BlockedIpsBoolExp>;
};

export type SubscriptionRootBlockedIpsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootBlockedIpsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<BlockedIpsStreamCursorInput>>;
  where?: InputMaybe<BlockedIpsBoolExp>;
};

export type SubscriptionRootBookmarkFoldersArgs = {
  distinct_on?: InputMaybe<Array<BookmarkFoldersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarkFoldersOrderBy>>;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
};

export type SubscriptionRootBookmarkFoldersAggregateArgs = {
  distinct_on?: InputMaybe<Array<BookmarkFoldersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarkFoldersOrderBy>>;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
};

export type SubscriptionRootBookmarkFoldersByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootBookmarkFoldersStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<BookmarkFoldersStreamCursorInput>>;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
};

export type SubscriptionRootBookmarksArgs = {
  distinct_on?: InputMaybe<Array<BookmarksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarksOrderBy>>;
  where?: InputMaybe<BookmarksBoolExp>;
};

export type SubscriptionRootBookmarksAggregateArgs = {
  distinct_on?: InputMaybe<Array<BookmarksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarksOrderBy>>;
  where?: InputMaybe<BookmarksBoolExp>;
};

export type SubscriptionRootBookmarksByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootBookmarksStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<BookmarksStreamCursorInput>>;
  where?: InputMaybe<BookmarksBoolExp>;
};

export type SubscriptionRootBusinessDomainsArgs = {
  distinct_on?: InputMaybe<Array<BusinessDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BusinessDomainsOrderBy>>;
  where?: InputMaybe<BusinessDomainsBoolExp>;
};

export type SubscriptionRootBusinessDomainsAggregateArgs = {
  distinct_on?: InputMaybe<Array<BusinessDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BusinessDomainsOrderBy>>;
  where?: InputMaybe<BusinessDomainsBoolExp>;
};

export type SubscriptionRootBusinessDomainsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootBusinessDomainsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<BusinessDomainsStreamCursorInput>>;
  where?: InputMaybe<BusinessDomainsBoolExp>;
};

export type SubscriptionRootCategoriesArgs = {
  distinct_on?: InputMaybe<Array<CategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategoriesOrderBy>>;
  where?: InputMaybe<CategoriesBoolExp>;
};

export type SubscriptionRootCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategoriesOrderBy>>;
  where?: InputMaybe<CategoriesBoolExp>;
};

export type SubscriptionRootCategoriesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootCategoriesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CategoriesStreamCursorInput>>;
  where?: InputMaybe<CategoriesBoolExp>;
};

export type SubscriptionRootCategorizedUrlsArgs = {
  distinct_on?: InputMaybe<Array<CategorizedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategorizedUrlsOrderBy>>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
};

export type SubscriptionRootCategorizedUrlsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CategorizedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategorizedUrlsOrderBy>>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
};

export type SubscriptionRootCategorizedUrlsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootCategorizedUrlsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CategorizedUrlsStreamCursorInput>>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
};

export type SubscriptionRootCircuitBreakerStatesArgs = {
  distinct_on?: InputMaybe<Array<CircuitBreakerStatesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CircuitBreakerStatesOrderBy>>;
  where?: InputMaybe<CircuitBreakerStatesBoolExp>;
};

export type SubscriptionRootCircuitBreakerStatesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CircuitBreakerStatesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CircuitBreakerStatesOrderBy>>;
  where?: InputMaybe<CircuitBreakerStatesBoolExp>;
};

export type SubscriptionRootCircuitBreakerStatesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootCircuitBreakerStatesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CircuitBreakerStatesStreamCursorInput>>;
  where?: InputMaybe<CircuitBreakerStatesBoolExp>;
};

export type SubscriptionRootCitiesArgs = {
  distinct_on?: InputMaybe<Array<CitiesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CitiesOrderBy>>;
  where?: InputMaybe<CitiesBoolExp>;
};

export type SubscriptionRootCitiesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CitiesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CitiesOrderBy>>;
  where?: InputMaybe<CitiesBoolExp>;
};

export type SubscriptionRootCitiesByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCitiesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CitiesStreamCursorInput>>;
  where?: InputMaybe<CitiesBoolExp>;
};

export type SubscriptionRootCommentsArgs = {
  distinct_on?: InputMaybe<Array<CommentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CommentsOrderBy>>;
  where?: InputMaybe<CommentsBoolExp>;
};

export type SubscriptionRootCommentsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CommentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CommentsOrderBy>>;
  where?: InputMaybe<CommentsBoolExp>;
};

export type SubscriptionRootCommentsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootCommentsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CommentsStreamCursorInput>>;
  where?: InputMaybe<CommentsBoolExp>;
};

export type SubscriptionRootCompaniesArgs = {
  distinct_on?: InputMaybe<Array<CompaniesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompaniesOrderBy>>;
  where?: InputMaybe<CompaniesBoolExp>;
};

export type SubscriptionRootCompaniesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompaniesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompaniesOrderBy>>;
  where?: InputMaybe<CompaniesBoolExp>;
};

export type SubscriptionRootCompaniesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootCompaniesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CompaniesStreamCursorInput>>;
  where?: InputMaybe<CompaniesBoolExp>;
};

export type SubscriptionRootCompanyContactsArgs = {
  distinct_on?: InputMaybe<Array<CompanyContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyContactsOrderBy>>;
  where?: InputMaybe<CompanyContactsBoolExp>;
};

export type SubscriptionRootCompanyContactsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompanyContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyContactsOrderBy>>;
  where?: InputMaybe<CompanyContactsBoolExp>;
};

export type SubscriptionRootCompanyContactsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCompanyContactsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CompanyContactsStreamCursorInput>>;
  where?: InputMaybe<CompanyContactsBoolExp>;
};

export type SubscriptionRootCompanyEmployeesArgs = {
  distinct_on?: InputMaybe<Array<CompanyEmployeesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyEmployeesOrderBy>>;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
};

export type SubscriptionRootCompanyEmployeesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompanyEmployeesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyEmployeesOrderBy>>;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
};

export type SubscriptionRootCompanyEmployeesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootCompanyEmployeesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CompanyEmployeesStreamCursorInput>>;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
};

export type SubscriptionRootCompanyExtrasArgs = {
  distinct_on?: InputMaybe<Array<CompanyExtrasSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyExtrasOrderBy>>;
  where?: InputMaybe<CompanyExtrasBoolExp>;
};

export type SubscriptionRootCompanyExtrasAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompanyExtrasSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyExtrasOrderBy>>;
  where?: InputMaybe<CompanyExtrasBoolExp>;
};

export type SubscriptionRootCompanyExtrasByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCompanyExtrasStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CompanyExtrasStreamCursorInput>>;
  where?: InputMaybe<CompanyExtrasBoolExp>;
};

export type SubscriptionRootCompanyMetricsArgs = {
  distinct_on?: InputMaybe<Array<CompanyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyMetricsOrderBy>>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
};

export type SubscriptionRootCompanyMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompanyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyMetricsOrderBy>>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
};

export type SubscriptionRootCompanyMetricsByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootCompanyMetricsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CompanyMetricsStreamCursorInput>>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
};

export type SubscriptionRootContactsArgs = {
  distinct_on?: InputMaybe<Array<ContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContactsOrderBy>>;
  where?: InputMaybe<ContactsBoolExp>;
};

export type SubscriptionRootContactsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContactsOrderBy>>;
  where?: InputMaybe<ContactsBoolExp>;
};

export type SubscriptionRootContactsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootContactsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ContactsStreamCursorInput>>;
  where?: InputMaybe<ContactsBoolExp>;
};

export type SubscriptionRootContentCategoriesArgs = {
  distinct_on?: InputMaybe<Array<ContentCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentCategoriesOrderBy>>;
  where?: InputMaybe<ContentCategoriesBoolExp>;
};

export type SubscriptionRootContentCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentCategoriesOrderBy>>;
  where?: InputMaybe<ContentCategoriesBoolExp>;
};

export type SubscriptionRootContentCategoriesByPkArgs = {
  category_id: Scalars["bigint"]["input"];
  content_id: Scalars["uuid"]["input"];
};

export type SubscriptionRootContentCategoriesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ContentCategoriesStreamCursorInput>>;
  where?: InputMaybe<ContentCategoriesBoolExp>;
};

export type SubscriptionRootContentScoresArgs = {
  distinct_on?: InputMaybe<Array<ContentScoresSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentScoresOrderBy>>;
  where?: InputMaybe<ContentScoresBoolExp>;
};

export type SubscriptionRootContentScoresAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentScoresSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentScoresOrderBy>>;
  where?: InputMaybe<ContentScoresBoolExp>;
};

export type SubscriptionRootContentScoresStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ContentScoresStreamCursorInput>>;
  where?: InputMaybe<ContentScoresBoolExp>;
};

export type SubscriptionRootContentSourceVisitsArgs = {
  distinct_on?: InputMaybe<Array<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

export type SubscriptionRootContentSourceVisitsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

export type SubscriptionRootContentSourceVisitsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootContentSourceVisitsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ContentSourceVisitsStreamCursorInput>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

export type SubscriptionRootContentSourcesArgs = {
  distinct_on?: InputMaybe<Array<ContentSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourcesOrderBy>>;
  where?: InputMaybe<ContentSourcesBoolExp>;
};

export type SubscriptionRootContentSourcesAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourcesOrderBy>>;
  where?: InputMaybe<ContentSourcesBoolExp>;
};

export type SubscriptionRootContentSourcesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootContentSourcesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ContentSourcesStreamCursorInput>>;
  where?: InputMaybe<ContentSourcesBoolExp>;
};

export type SubscriptionRootContentStatusesArgs = {
  distinct_on?: InputMaybe<Array<ContentStatusesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentStatusesOrderBy>>;
  where?: InputMaybe<ContentStatusesBoolExp>;
};

export type SubscriptionRootContentStatusesAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentStatusesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentStatusesOrderBy>>;
  where?: InputMaybe<ContentStatusesBoolExp>;
};

export type SubscriptionRootContentStatusesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootContentStatusesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ContentStatusesStreamCursorInput>>;
  where?: InputMaybe<ContentStatusesBoolExp>;
};

export type SubscriptionRootContentTagsArgs = {
  distinct_on?: InputMaybe<Array<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentTagsOrderBy>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

export type SubscriptionRootContentTagsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentTagsOrderBy>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

export type SubscriptionRootContentTagsByPkArgs = {
  content_id: Scalars["uuid"]["input"];
  tag_id: Scalars["Int"]["input"];
};

export type SubscriptionRootContentTagsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ContentTagsStreamCursorInput>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

export type SubscriptionRootContentsArgs = {
  distinct_on?: InputMaybe<Array<ContentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentsOrderBy>>;
  where?: InputMaybe<ContentsBoolExp>;
};

export type SubscriptionRootContentsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentsOrderBy>>;
  where?: InputMaybe<ContentsBoolExp>;
};

export type SubscriptionRootContentsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootContentsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ContentsStreamCursorInput>>;
  where?: InputMaybe<ContentsBoolExp>;
};

export type SubscriptionRootCountriesArgs = {
  distinct_on?: InputMaybe<Array<CountriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CountriesOrderBy>>;
  where?: InputMaybe<CountriesBoolExp>;
};

export type SubscriptionRootCountriesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CountriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CountriesOrderBy>>;
  where?: InputMaybe<CountriesBoolExp>;
};

export type SubscriptionRootCountriesByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCountriesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CountriesStreamCursorInput>>;
  where?: InputMaybe<CountriesBoolExp>;
};

export type SubscriptionRootCustomerPaymentsArgs = {
  distinct_on?: InputMaybe<Array<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

export type SubscriptionRootCustomerPaymentsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

export type SubscriptionRootCustomerPaymentsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCustomerPaymentsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CustomerPaymentsStreamCursorInput>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

export type SubscriptionRootCustomerProcessedWebhooksArgs = {
  distinct_on?: InputMaybe<Array<CustomerProcessedWebhooksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerProcessedWebhooksOrderBy>>;
  where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
};

export type SubscriptionRootCustomerProcessedWebhooksAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerProcessedWebhooksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerProcessedWebhooksOrderBy>>;
  where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
};

export type SubscriptionRootCustomerProcessedWebhooksByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCustomerProcessedWebhooksStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CustomerProcessedWebhooksStreamCursorInput>>;
  where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
};

export type SubscriptionRootCustomerRefundsArgs = {
  distinct_on?: InputMaybe<Array<CustomerRefundsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerRefundsOrderBy>>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
};

export type SubscriptionRootCustomerRefundsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerRefundsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerRefundsOrderBy>>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
};

export type SubscriptionRootCustomerRefundsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCustomerRefundsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CustomerRefundsStreamCursorInput>>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
};

export type SubscriptionRootCustomerSubscriptionPlansArgs = {
  distinct_on?: InputMaybe<Array<CustomerSubscriptionPlansSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerSubscriptionPlansOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
};

export type SubscriptionRootCustomerSubscriptionPlansAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerSubscriptionPlansSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerSubscriptionPlansOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
};

export type SubscriptionRootCustomerSubscriptionPlansByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCustomerSubscriptionPlansStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CustomerSubscriptionPlansStreamCursorInput>>;
  where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
};

export type SubscriptionRootCustomerSubscriptionsArgs = {
  distinct_on?: InputMaybe<Array<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

export type SubscriptionRootCustomerSubscriptionsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

export type SubscriptionRootCustomerSubscriptionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCustomerSubscriptionsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<CustomerSubscriptionsStreamCursorInput>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

export type SubscriptionRootEmbeddingReviewsArgs = {
  distinct_on?: InputMaybe<Array<EmbeddingReviewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<EmbeddingReviewsOrderBy>>;
  where?: InputMaybe<EmbeddingReviewsBoolExp>;
};

export type SubscriptionRootEmbeddingReviewsAggregateArgs = {
  distinct_on?: InputMaybe<Array<EmbeddingReviewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<EmbeddingReviewsOrderBy>>;
  where?: InputMaybe<EmbeddingReviewsBoolExp>;
};

export type SubscriptionRootEmbeddingReviewsByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootEmbeddingReviewsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<EmbeddingReviewsStreamCursorInput>>;
  where?: InputMaybe<EmbeddingReviewsBoolExp>;
};

export type SubscriptionRootErrorCorrelationsArgs = {
  distinct_on?: InputMaybe<Array<ErrorCorrelationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorCorrelationsOrderBy>>;
  where?: InputMaybe<ErrorCorrelationsBoolExp>;
};

export type SubscriptionRootErrorCorrelationsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ErrorCorrelationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorCorrelationsOrderBy>>;
  where?: InputMaybe<ErrorCorrelationsBoolExp>;
};

export type SubscriptionRootErrorCorrelationsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ErrorCorrelationsStreamCursorInput>>;
  where?: InputMaybe<ErrorCorrelationsBoolExp>;
};

export type SubscriptionRootErrorFrequencyArgs = {
  distinct_on?: InputMaybe<Array<ErrorFrequencySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorFrequencyOrderBy>>;
  where?: InputMaybe<ErrorFrequencyBoolExp>;
};

export type SubscriptionRootErrorFrequencyAggregateArgs = {
  distinct_on?: InputMaybe<Array<ErrorFrequencySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorFrequencyOrderBy>>;
  where?: InputMaybe<ErrorFrequencyBoolExp>;
};

export type SubscriptionRootErrorFrequencyStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ErrorFrequencyStreamCursorInput>>;
  where?: InputMaybe<ErrorFrequencyBoolExp>;
};

export type SubscriptionRootErrorLogsArgs = {
  distinct_on?: InputMaybe<Array<ErrorLogsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorLogsOrderBy>>;
  where?: InputMaybe<ErrorLogsBoolExp>;
};

export type SubscriptionRootErrorLogsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ErrorLogsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorLogsOrderBy>>;
  where?: InputMaybe<ErrorLogsBoolExp>;
};

export type SubscriptionRootErrorLogsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootErrorLogsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ErrorLogsStreamCursorInput>>;
  where?: InputMaybe<ErrorLogsBoolExp>;
};

export type SubscriptionRootErrorMetricsArgs = {
  distinct_on?: InputMaybe<Array<ErrorMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorMetricsOrderBy>>;
  where?: InputMaybe<ErrorMetricsBoolExp>;
};

export type SubscriptionRootErrorMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ErrorMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorMetricsOrderBy>>;
  where?: InputMaybe<ErrorMetricsBoolExp>;
};

export type SubscriptionRootErrorMetricsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ErrorMetricsStreamCursorInput>>;
  where?: InputMaybe<ErrorMetricsBoolExp>;
};

export type SubscriptionRootErrorPatternsArgs = {
  distinct_on?: InputMaybe<Array<ErrorPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorPatternsOrderBy>>;
  where?: InputMaybe<ErrorPatternsBoolExp>;
};

export type SubscriptionRootErrorPatternsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ErrorPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorPatternsOrderBy>>;
  where?: InputMaybe<ErrorPatternsBoolExp>;
};

export type SubscriptionRootErrorPatternsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ErrorPatternsStreamCursorInput>>;
  where?: InputMaybe<ErrorPatternsBoolExp>;
};

export type SubscriptionRootErrorStatsArgs = {
  distinct_on?: InputMaybe<Array<ErrorStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorStatsOrderBy>>;
  where?: InputMaybe<ErrorStatsBoolExp>;
};

export type SubscriptionRootErrorStatsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ErrorStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorStatsOrderBy>>;
  where?: InputMaybe<ErrorStatsBoolExp>;
};

export type SubscriptionRootErrorStatsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ErrorStatsStreamCursorInput>>;
  where?: InputMaybe<ErrorStatsBoolExp>;
};

export type SubscriptionRootFeatureRequestsArgs = {
  distinct_on?: InputMaybe<Array<FeatureRequestsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeatureRequestsOrderBy>>;
  where?: InputMaybe<FeatureRequestsBoolExp>;
};

export type SubscriptionRootFeatureRequestsAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeatureRequestsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeatureRequestsOrderBy>>;
  where?: InputMaybe<FeatureRequestsBoolExp>;
};

export type SubscriptionRootFeatureRequestsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootFeatureRequestsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<FeatureRequestsStreamCursorInput>>;
  where?: InputMaybe<FeatureRequestsBoolExp>;
};

export type SubscriptionRootFeatureVotesArgs = {
  distinct_on?: InputMaybe<Array<FeatureVotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeatureVotesOrderBy>>;
  where?: InputMaybe<FeatureVotesBoolExp>;
};

export type SubscriptionRootFeatureVotesAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeatureVotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeatureVotesOrderBy>>;
  where?: InputMaybe<FeatureVotesBoolExp>;
};

export type SubscriptionRootFeatureVotesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootFeatureVotesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<FeatureVotesStreamCursorInput>>;
  where?: InputMaybe<FeatureVotesBoolExp>;
};

export type SubscriptionRootFeedCategoriesArgs = {
  distinct_on?: InputMaybe<Array<FeedCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedCategoriesOrderBy>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

export type SubscriptionRootFeedCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeedCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedCategoriesOrderBy>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

export type SubscriptionRootFeedCategoriesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootFeedCategoriesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<FeedCategoriesStreamCursorInput>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

export type SubscriptionRootFeedSourcesArgs = {
  distinct_on?: InputMaybe<Array<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

export type SubscriptionRootFeedSourcesAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

export type SubscriptionRootFeedSourcesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootFeedSourcesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<FeedSourcesStreamCursorInput>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

export type SubscriptionRootFeedbacksArgs = {
  distinct_on?: InputMaybe<Array<FeedbacksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedbacksOrderBy>>;
  where?: InputMaybe<FeedbacksBoolExp>;
};

export type SubscriptionRootFeedbacksAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeedbacksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedbacksOrderBy>>;
  where?: InputMaybe<FeedbacksBoolExp>;
};

export type SubscriptionRootFeedbacksByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootFeedbacksStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<FeedbacksStreamCursorInput>>;
  where?: InputMaybe<FeedbacksBoolExp>;
};

export type SubscriptionRootFeedsArgs = {
  distinct_on?: InputMaybe<Array<FeedsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedsOrderBy>>;
  where?: InputMaybe<FeedsBoolExp>;
};

export type SubscriptionRootFeedsAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeedsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedsOrderBy>>;
  where?: InputMaybe<FeedsBoolExp>;
};

export type SubscriptionRootFeedsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootFeedsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<FeedsStreamCursorInput>>;
  where?: InputMaybe<FeedsBoolExp>;
};

export type SubscriptionRootFollowsArgs = {
  distinct_on?: InputMaybe<Array<FollowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FollowsOrderBy>>;
  where?: InputMaybe<FollowsBoolExp>;
};

export type SubscriptionRootFollowsAggregateArgs = {
  distinct_on?: InputMaybe<Array<FollowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FollowsOrderBy>>;
  where?: InputMaybe<FollowsBoolExp>;
};

export type SubscriptionRootFollowsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootFollowsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<FollowsStreamCursorInput>>;
  where?: InputMaybe<FollowsBoolExp>;
};

export type SubscriptionRootMetricDefinitionsArgs = {
  distinct_on?: InputMaybe<Array<MetricDefinitionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<MetricDefinitionsOrderBy>>;
  where?: InputMaybe<MetricDefinitionsBoolExp>;
};

export type SubscriptionRootMetricDefinitionsAggregateArgs = {
  distinct_on?: InputMaybe<Array<MetricDefinitionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<MetricDefinitionsOrderBy>>;
  where?: InputMaybe<MetricDefinitionsBoolExp>;
};

export type SubscriptionRootMetricDefinitionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootMetricDefinitionsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<MetricDefinitionsStreamCursorInput>>;
  where?: InputMaybe<MetricDefinitionsBoolExp>;
};

export type SubscriptionRootNewsArgs = {
  distinct_on?: InputMaybe<Array<NewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsOrderBy>>;
  where?: InputMaybe<NewsBoolExp>;
};

export type SubscriptionRootNewsAggregateArgs = {
  distinct_on?: InputMaybe<Array<NewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsOrderBy>>;
  where?: InputMaybe<NewsBoolExp>;
};

export type SubscriptionRootNewsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootNewsDetailsArgs = {
  distinct_on?: InputMaybe<Array<NewsDetailsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsDetailsOrderBy>>;
  where?: InputMaybe<NewsDetailsBoolExp>;
};

export type SubscriptionRootNewsDetailsAggregateArgs = {
  distinct_on?: InputMaybe<Array<NewsDetailsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsDetailsOrderBy>>;
  where?: InputMaybe<NewsDetailsBoolExp>;
};

export type SubscriptionRootNewsDetailsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<NewsDetailsStreamCursorInput>>;
  where?: InputMaybe<NewsDetailsBoolExp>;
};

export type SubscriptionRootNewsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<NewsStreamCursorInput>>;
  where?: InputMaybe<NewsBoolExp>;
};

export type SubscriptionRootNewsSummariesArgs = {
  distinct_on?: InputMaybe<Array<NewsSummariesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsSummariesOrderBy>>;
  where?: InputMaybe<NewsSummariesBoolExp>;
};

export type SubscriptionRootNewsSummariesAggregateArgs = {
  distinct_on?: InputMaybe<Array<NewsSummariesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsSummariesOrderBy>>;
  where?: InputMaybe<NewsSummariesBoolExp>;
};

export type SubscriptionRootNewsSummariesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootNewsSummariesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<NewsSummariesStreamCursorInput>>;
  where?: InputMaybe<NewsSummariesBoolExp>;
};

export type SubscriptionRootNewsTagsArgs = {
  distinct_on?: InputMaybe<Array<NewsTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsTagsOrderBy>>;
  where?: InputMaybe<NewsTagsBoolExp>;
};

export type SubscriptionRootNewsTagsAggregateArgs = {
  distinct_on?: InputMaybe<Array<NewsTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsTagsOrderBy>>;
  where?: InputMaybe<NewsTagsBoolExp>;
};

export type SubscriptionRootNewsTagsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootNewsTagsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<NewsTagsStreamCursorInput>>;
  where?: InputMaybe<NewsTagsBoolExp>;
};

export type SubscriptionRootNewslettersArgs = {
  distinct_on?: InputMaybe<Array<NewslettersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewslettersOrderBy>>;
  where?: InputMaybe<NewslettersBoolExp>;
};

export type SubscriptionRootNewslettersAggregateArgs = {
  distinct_on?: InputMaybe<Array<NewslettersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewslettersOrderBy>>;
  where?: InputMaybe<NewslettersBoolExp>;
};

export type SubscriptionRootNewslettersByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootNewslettersStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<NewslettersStreamCursorInput>>;
  where?: InputMaybe<NewslettersBoolExp>;
};

export type SubscriptionRootPaymentProvidersArgs = {
  distinct_on?: InputMaybe<Array<PaymentProvidersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<PaymentProvidersOrderBy>>;
  where?: InputMaybe<PaymentProvidersBoolExp>;
};

export type SubscriptionRootPaymentProvidersAggregateArgs = {
  distinct_on?: InputMaybe<Array<PaymentProvidersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<PaymentProvidersOrderBy>>;
  where?: InputMaybe<PaymentProvidersBoolExp>;
};

export type SubscriptionRootPaymentProvidersByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootPaymentProvidersStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<PaymentProvidersStreamCursorInput>>;
  where?: InputMaybe<PaymentProvidersBoolExp>;
};

export type SubscriptionRootPlanPermissionsArgs = {
  distinct_on?: InputMaybe<Array<PlanPermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<PlanPermissionsOrderBy>>;
  where?: InputMaybe<PlanPermissionsBoolExp>;
};

export type SubscriptionRootPlanPermissionsAggregateArgs = {
  distinct_on?: InputMaybe<Array<PlanPermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<PlanPermissionsOrderBy>>;
  where?: InputMaybe<PlanPermissionsBoolExp>;
};

export type SubscriptionRootPlanPermissionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootPlanPermissionsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<PlanPermissionsStreamCursorInput>>;
  where?: InputMaybe<PlanPermissionsBoolExp>;
};

export type SubscriptionRootRecentErrorsArgs = {
  distinct_on?: InputMaybe<Array<RecentErrorsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RecentErrorsOrderBy>>;
  where?: InputMaybe<RecentErrorsBoolExp>;
};

export type SubscriptionRootRecentErrorsAggregateArgs = {
  distinct_on?: InputMaybe<Array<RecentErrorsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RecentErrorsOrderBy>>;
  where?: InputMaybe<RecentErrorsBoolExp>;
};

export type SubscriptionRootRecentErrorsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<RecentErrorsStreamCursorInput>>;
  where?: InputMaybe<RecentErrorsBoolExp>;
};

export type SubscriptionRootReferralStatsArgs = {
  distinct_on?: InputMaybe<Array<ReferralStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferralStatsOrderBy>>;
  where?: InputMaybe<ReferralStatsBoolExp>;
};

export type SubscriptionRootReferralStatsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ReferralStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferralStatsOrderBy>>;
  where?: InputMaybe<ReferralStatsBoolExp>;
};

export type SubscriptionRootReferralStatsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ReferralStatsStreamCursorInput>>;
  where?: InputMaybe<ReferralStatsBoolExp>;
};

export type SubscriptionRootReferralsArgs = {
  distinct_on?: InputMaybe<Array<ReferralsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferralsOrderBy>>;
  where?: InputMaybe<ReferralsBoolExp>;
};

export type SubscriptionRootReferralsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ReferralsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferralsOrderBy>>;
  where?: InputMaybe<ReferralsBoolExp>;
};

export type SubscriptionRootReferralsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootReferralsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ReferralsStreamCursorInput>>;
  where?: InputMaybe<ReferralsBoolExp>;
};

export type SubscriptionRootReferrerBlocksArgs = {
  distinct_on?: InputMaybe<Array<ReferrerBlocksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferrerBlocksOrderBy>>;
  where?: InputMaybe<ReferrerBlocksBoolExp>;
};

export type SubscriptionRootReferrerBlocksAggregateArgs = {
  distinct_on?: InputMaybe<Array<ReferrerBlocksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferrerBlocksOrderBy>>;
  where?: InputMaybe<ReferrerBlocksBoolExp>;
};

export type SubscriptionRootReferrerBlocksByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootReferrerBlocksStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ReferrerBlocksStreamCursorInput>>;
  where?: InputMaybe<ReferrerBlocksBoolExp>;
};

export type SubscriptionRootReferrerRiskMetricsArgs = {
  distinct_on?: InputMaybe<Array<ReferrerRiskMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferrerRiskMetricsOrderBy>>;
  where?: InputMaybe<ReferrerRiskMetricsBoolExp>;
};

export type SubscriptionRootReferrerRiskMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ReferrerRiskMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferrerRiskMetricsOrderBy>>;
  where?: InputMaybe<ReferrerRiskMetricsBoolExp>;
};

export type SubscriptionRootReferrerRiskMetricsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ReferrerRiskMetricsStreamCursorInput>>;
  where?: InputMaybe<ReferrerRiskMetricsBoolExp>;
};

export type SubscriptionRootResearchArgs = {
  distinct_on?: InputMaybe<Array<ResearchSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResearchOrderBy>>;
  where?: InputMaybe<ResearchBoolExp>;
};

export type SubscriptionRootResearchAggregateArgs = {
  distinct_on?: InputMaybe<Array<ResearchSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResearchOrderBy>>;
  where?: InputMaybe<ResearchBoolExp>;
};

export type SubscriptionRootResearchByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootResearchEmbeddingsArgs = {
  distinct_on?: InputMaybe<Array<ResearchEmbeddingsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResearchEmbeddingsOrderBy>>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

export type SubscriptionRootResearchEmbeddingsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ResearchEmbeddingsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResearchEmbeddingsOrderBy>>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

export type SubscriptionRootResearchEmbeddingsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootResearchEmbeddingsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ResearchEmbeddingsStreamCursorInput>>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

export type SubscriptionRootResearchStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ResearchStreamCursorInput>>;
  where?: InputMaybe<ResearchBoolExp>;
};

export type SubscriptionRootResponsesArgs = {
  distinct_on?: InputMaybe<Array<ResponsesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResponsesOrderBy>>;
  where?: InputMaybe<ResponsesBoolExp>;
};

export type SubscriptionRootResponsesAggregateArgs = {
  distinct_on?: InputMaybe<Array<ResponsesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResponsesOrderBy>>;
  where?: InputMaybe<ResponsesBoolExp>;
};

export type SubscriptionRootResponsesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootResponsesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ResponsesStreamCursorInput>>;
  where?: InputMaybe<ResponsesBoolExp>;
};

export type SubscriptionRootRoleHierarchyArgs = {
  distinct_on?: InputMaybe<Array<RoleHierarchySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RoleHierarchyOrderBy>>;
  where?: InputMaybe<RoleHierarchyBoolExp>;
};

export type SubscriptionRootRoleHierarchyAggregateArgs = {
  distinct_on?: InputMaybe<Array<RoleHierarchySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RoleHierarchyOrderBy>>;
  where?: InputMaybe<RoleHierarchyBoolExp>;
};

export type SubscriptionRootRoleHierarchyByPkArgs = {
  child_role: Scalars["app_role_enum"]["input"];
  parent_role: Scalars["app_role_enum"]["input"];
};

export type SubscriptionRootRoleHierarchyStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<RoleHierarchyStreamCursorInput>>;
  where?: InputMaybe<RoleHierarchyBoolExp>;
};

export type SubscriptionRootRolePermissionsArgs = {
  distinct_on?: InputMaybe<Array<RolePermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RolePermissionsOrderBy>>;
  where?: InputMaybe<RolePermissionsBoolExp>;
};

export type SubscriptionRootRolePermissionsAggregateArgs = {
  distinct_on?: InputMaybe<Array<RolePermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RolePermissionsOrderBy>>;
  where?: InputMaybe<RolePermissionsBoolExp>;
};

export type SubscriptionRootRolePermissionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootRolePermissionsMaterializedArgs = {
  distinct_on?: InputMaybe<Array<RolePermissionsMaterializedSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RolePermissionsMaterializedOrderBy>>;
  where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
};

export type SubscriptionRootRolePermissionsMaterializedAggregateArgs = {
  distinct_on?: InputMaybe<Array<RolePermissionsMaterializedSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RolePermissionsMaterializedOrderBy>>;
  where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
};

export type SubscriptionRootRolePermissionsMaterializedByPkArgs = {
  role: Scalars["app_role_enum"]["input"];
};

export type SubscriptionRootRolePermissionsMaterializedStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<RolePermissionsMaterializedStreamCursorInput>>;
  where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
};

export type SubscriptionRootRolePermissionsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<RolePermissionsStreamCursorInput>>;
  where?: InputMaybe<RolePermissionsBoolExp>;
};

export type SubscriptionRootScoringWeightsArgs = {
  distinct_on?: InputMaybe<Array<ScoringWeightsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ScoringWeightsOrderBy>>;
  where?: InputMaybe<ScoringWeightsBoolExp>;
};

export type SubscriptionRootScoringWeightsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ScoringWeightsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ScoringWeightsOrderBy>>;
  where?: InputMaybe<ScoringWeightsBoolExp>;
};

export type SubscriptionRootScoringWeightsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootScoringWeightsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<ScoringWeightsStreamCursorInput>>;
  where?: InputMaybe<ScoringWeightsBoolExp>;
};

export type SubscriptionRootSearchesArgs = {
  distinct_on?: InputMaybe<Array<SearchesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SearchesOrderBy>>;
  where?: InputMaybe<SearchesBoolExp>;
};

export type SubscriptionRootSearchesAggregateArgs = {
  distinct_on?: InputMaybe<Array<SearchesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SearchesOrderBy>>;
  where?: InputMaybe<SearchesBoolExp>;
};

export type SubscriptionRootSearchesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootSearchesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<SearchesStreamCursorInput>>;
  where?: InputMaybe<SearchesBoolExp>;
};

export type SubscriptionRootSecurityMetricsArgs = {
  distinct_on?: InputMaybe<Array<SecurityMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SecurityMetricsOrderBy>>;
  where?: InputMaybe<SecurityMetricsBoolExp>;
};

export type SubscriptionRootSecurityMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<SecurityMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SecurityMetricsOrderBy>>;
  where?: InputMaybe<SecurityMetricsBoolExp>;
};

export type SubscriptionRootSecurityMetricsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<SecurityMetricsStreamCursorInput>>;
  where?: InputMaybe<SecurityMetricsBoolExp>;
};

export type SubscriptionRootSlowQueryPatternsArgs = {
  distinct_on?: InputMaybe<Array<SlowQueryPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SlowQueryPatternsOrderBy>>;
  where?: InputMaybe<SlowQueryPatternsBoolExp>;
};

export type SubscriptionRootSlowQueryPatternsAggregateArgs = {
  distinct_on?: InputMaybe<Array<SlowQueryPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SlowQueryPatternsOrderBy>>;
  where?: InputMaybe<SlowQueryPatternsBoolExp>;
};

export type SubscriptionRootSlowQueryPatternsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<SlowQueryPatternsStreamCursorInput>>;
  where?: InputMaybe<SlowQueryPatternsBoolExp>;
};

export type SubscriptionRootSocialMediaArgs = {
  distinct_on?: InputMaybe<Array<SocialMediaSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SocialMediaOrderBy>>;
  where?: InputMaybe<SocialMediaBoolExp>;
};

export type SubscriptionRootSocialMediaAggregateArgs = {
  distinct_on?: InputMaybe<Array<SocialMediaSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SocialMediaOrderBy>>;
  where?: InputMaybe<SocialMediaBoolExp>;
};

export type SubscriptionRootSocialMediaByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootSocialMediaStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<SocialMediaStreamCursorInput>>;
  where?: InputMaybe<SocialMediaBoolExp>;
};

export type SubscriptionRootSpiderMetricsArgs = {
  distinct_on?: InputMaybe<Array<SpiderMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SpiderMetricsOrderBy>>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
};

export type SubscriptionRootSpiderMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<SpiderMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SpiderMetricsOrderBy>>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
};

export type SubscriptionRootSpiderMetricsByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootSpiderMetricsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<SpiderMetricsStreamCursorInput>>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
};

export type SubscriptionRootStrapiMigrationsArgs = {
  distinct_on?: InputMaybe<Array<StrapiMigrationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<StrapiMigrationsOrderBy>>;
  where?: InputMaybe<StrapiMigrationsBoolExp>;
};

export type SubscriptionRootStrapiMigrationsAggregateArgs = {
  distinct_on?: InputMaybe<Array<StrapiMigrationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<StrapiMigrationsOrderBy>>;
  where?: InputMaybe<StrapiMigrationsBoolExp>;
};

export type SubscriptionRootStrapiMigrationsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootStrapiMigrationsInternalArgs = {
  distinct_on?: InputMaybe<Array<StrapiMigrationsInternalSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<StrapiMigrationsInternalOrderBy>>;
  where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
};

export type SubscriptionRootStrapiMigrationsInternalAggregateArgs = {
  distinct_on?: InputMaybe<Array<StrapiMigrationsInternalSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<StrapiMigrationsInternalOrderBy>>;
  where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
};

export type SubscriptionRootStrapiMigrationsInternalByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootStrapiMigrationsInternalStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<StrapiMigrationsInternalStreamCursorInput>>;
  where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
};

export type SubscriptionRootStrapiMigrationsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<StrapiMigrationsStreamCursorInput>>;
  where?: InputMaybe<StrapiMigrationsBoolExp>;
};

export type SubscriptionRootTableMaintenanceLogArgs = {
  distinct_on?: InputMaybe<Array<TableMaintenanceLogSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableMaintenanceLogOrderBy>>;
  where?: InputMaybe<TableMaintenanceLogBoolExp>;
};

export type SubscriptionRootTableMaintenanceLogAggregateArgs = {
  distinct_on?: InputMaybe<Array<TableMaintenanceLogSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableMaintenanceLogOrderBy>>;
  where?: InputMaybe<TableMaintenanceLogBoolExp>;
};

export type SubscriptionRootTableMaintenanceLogByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootTableMaintenanceLogStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<TableMaintenanceLogStreamCursorInput>>;
  where?: InputMaybe<TableMaintenanceLogBoolExp>;
};

export type SubscriptionRootTableQueryPerformanceArgs = {
  distinct_on?: InputMaybe<Array<TableQueryPerformanceSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableQueryPerformanceOrderBy>>;
  where?: InputMaybe<TableQueryPerformanceBoolExp>;
};

export type SubscriptionRootTableQueryPerformanceAggregateArgs = {
  distinct_on?: InputMaybe<Array<TableQueryPerformanceSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableQueryPerformanceOrderBy>>;
  where?: InputMaybe<TableQueryPerformanceBoolExp>;
};

export type SubscriptionRootTableQueryPerformanceStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<TableQueryPerformanceStreamCursorInput>>;
  where?: InputMaybe<TableQueryPerformanceBoolExp>;
};

export type SubscriptionRootTableSequenceUsageArgs = {
  distinct_on?: InputMaybe<Array<TableSequenceUsageSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableSequenceUsageOrderBy>>;
  where?: InputMaybe<TableSequenceUsageBoolExp>;
};

export type SubscriptionRootTableSequenceUsageAggregateArgs = {
  distinct_on?: InputMaybe<Array<TableSequenceUsageSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableSequenceUsageOrderBy>>;
  where?: InputMaybe<TableSequenceUsageBoolExp>;
};

export type SubscriptionRootTableSequenceUsageStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<TableSequenceUsageStreamCursorInput>>;
  where?: InputMaybe<TableSequenceUsageBoolExp>;
};

export type SubscriptionRootTableStatisticsArgs = {
  distinct_on?: InputMaybe<Array<TableStatisticsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableStatisticsOrderBy>>;
  where?: InputMaybe<TableStatisticsBoolExp>;
};

export type SubscriptionRootTableStatisticsAggregateArgs = {
  distinct_on?: InputMaybe<Array<TableStatisticsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableStatisticsOrderBy>>;
  where?: InputMaybe<TableStatisticsBoolExp>;
};

export type SubscriptionRootTableStatisticsByPkArgs = {
  capture_time: Scalars["timestamptz"]["input"];
  table_name: Scalars["String"]["input"];
};

export type SubscriptionRootTableStatisticsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<TableStatisticsStreamCursorInput>>;
  where?: InputMaybe<TableStatisticsBoolExp>;
};

export type SubscriptionRootTagsArgs = {
  distinct_on?: InputMaybe<Array<TagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TagsOrderBy>>;
  where?: InputMaybe<TagsBoolExp>;
};

export type SubscriptionRootTagsAggregateArgs = {
  distinct_on?: InputMaybe<Array<TagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TagsOrderBy>>;
  where?: InputMaybe<TagsBoolExp>;
};

export type SubscriptionRootTagsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootTagsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<TagsStreamCursorInput>>;
  where?: InputMaybe<TagsBoolExp>;
};

export type SubscriptionRootUserMetricsArgs = {
  distinct_on?: InputMaybe<Array<UserMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<UserMetricsOrderBy>>;
  where?: InputMaybe<UserMetricsBoolExp>;
};

export type SubscriptionRootUserMetricsAggregateArgs = {
  distinct_on?: InputMaybe<Array<UserMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<UserMetricsOrderBy>>;
  where?: InputMaybe<UserMetricsBoolExp>;
};

export type SubscriptionRootUserMetricsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootUserMetricsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<UserMetricsStreamCursorInput>>;
  where?: InputMaybe<UserMetricsBoolExp>;
};

export type SubscriptionRootUserProfilesArgs = {
  distinct_on?: InputMaybe<Array<UserProfilesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<UserProfilesOrderBy>>;
  where?: InputMaybe<UserProfilesBoolExp>;
};

export type SubscriptionRootUserProfilesAggregateArgs = {
  distinct_on?: InputMaybe<Array<UserProfilesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<UserProfilesOrderBy>>;
  where?: InputMaybe<UserProfilesBoolExp>;
};

export type SubscriptionRootUserProfilesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootUserProfilesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<UserProfilesStreamCursorInput>>;
  where?: InputMaybe<UserProfilesBoolExp>;
};

export type SubscriptionRootVotesArgs = {
  distinct_on?: InputMaybe<Array<VotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<VotesOrderBy>>;
  where?: InputMaybe<VotesBoolExp>;
};

export type SubscriptionRootVotesAggregateArgs = {
  distinct_on?: InputMaybe<Array<VotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<VotesOrderBy>>;
  where?: InputMaybe<VotesBoolExp>;
};

export type SubscriptionRootVotesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootVotesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<VotesStreamCursorInput>>;
  where?: InputMaybe<VotesBoolExp>;
};

export type SubscriptionRootWorkflowsArgs = {
  distinct_on?: InputMaybe<Array<WorkflowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<WorkflowsOrderBy>>;
  where?: InputMaybe<WorkflowsBoolExp>;
};

export type SubscriptionRootWorkflowsAggregateArgs = {
  distinct_on?: InputMaybe<Array<WorkflowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<WorkflowsOrderBy>>;
  where?: InputMaybe<WorkflowsBoolExp>;
};

export type SubscriptionRootWorkflowsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootWorkflowsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: Array<InputMaybe<WorkflowsStreamCursorInput>>;
  where?: InputMaybe<WorkflowsBoolExp>;
};

/** columns and relationships of "table_maintenance_log" */
export type TableMaintenanceLog = {
  __typename?: "table_maintenance_log";
  detail?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["Int"]["output"];
  logged_at?: Maybe<Scalars["timestamptz"]["output"]>;
  operation?: Maybe<Scalars["String"]["output"]>;
};

/** aggregated selection of "table_maintenance_log" */
export type TableMaintenanceLogAggregate = {
  __typename?: "table_maintenance_log_aggregate";
  aggregate?: Maybe<TableMaintenanceLogAggregateFields>;
  nodes: Array<TableMaintenanceLog>;
};

/** aggregate fields of "table_maintenance_log" */
export type TableMaintenanceLogAggregateFields = {
  __typename?: "table_maintenance_log_aggregate_fields";
  avg?: Maybe<TableMaintenanceLogAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<TableMaintenanceLogMaxFields>;
  min?: Maybe<TableMaintenanceLogMinFields>;
  stddev?: Maybe<TableMaintenanceLogStddevFields>;
  stddev_pop?: Maybe<TableMaintenanceLogStddevPopFields>;
  stddev_samp?: Maybe<TableMaintenanceLogStddevSampFields>;
  sum?: Maybe<TableMaintenanceLogSumFields>;
  var_pop?: Maybe<TableMaintenanceLogVarPopFields>;
  var_samp?: Maybe<TableMaintenanceLogVarSampFields>;
  variance?: Maybe<TableMaintenanceLogVarianceFields>;
};

/** aggregate fields of "table_maintenance_log" */
export type TableMaintenanceLogAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<TableMaintenanceLogSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type TableMaintenanceLogAvgFields = {
  __typename?: "table_maintenance_log_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "table_maintenance_log". All fields are combined with a logical 'AND'. */
export type TableMaintenanceLogBoolExp = {
  _and?: InputMaybe<Array<TableMaintenanceLogBoolExp>>;
  _not?: InputMaybe<TableMaintenanceLogBoolExp>;
  _or?: InputMaybe<Array<TableMaintenanceLogBoolExp>>;
  detail?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  logged_at?: InputMaybe<TimestamptzComparisonExp>;
  operation?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "table_maintenance_log" */
export enum TableMaintenanceLogConstraint {
  /** unique or primary key constraint on columns "id" */
  TABLE_MAINTENANCE_LOG_PKEY = "table_maintenance_log_pkey",
}

/** input type for incrementing numeric columns in table "table_maintenance_log" */
export type TableMaintenanceLogIncInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "table_maintenance_log" */
export type TableMaintenanceLogInsertInput = {
  detail?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  logged_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  operation?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type TableMaintenanceLogMaxFields = {
  __typename?: "table_maintenance_log_max_fields";
  detail?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  logged_at?: Maybe<Scalars["timestamptz"]["output"]>;
  operation?: Maybe<Scalars["String"]["output"]>;
};

/** aggregate min on columns */
export type TableMaintenanceLogMinFields = {
  __typename?: "table_maintenance_log_min_fields";
  detail?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  logged_at?: Maybe<Scalars["timestamptz"]["output"]>;
  operation?: Maybe<Scalars["String"]["output"]>;
};

/** response of any mutation on the table "table_maintenance_log" */
export type TableMaintenanceLogMutationResponse = {
  __typename?: "table_maintenance_log_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<TableMaintenanceLog>;
};

/** on_conflict condition type for table "table_maintenance_log" */
export type TableMaintenanceLogOnConflict = {
  constraint: TableMaintenanceLogConstraint;
  update_columns?: Array<TableMaintenanceLogUpdateColumn>;
  where?: InputMaybe<TableMaintenanceLogBoolExp>;
};

/** Ordering options when selecting data from "table_maintenance_log". */
export type TableMaintenanceLogOrderBy = {
  detail?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  logged_at?: InputMaybe<OrderBy>;
  operation?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: table_maintenance_log */
export type TableMaintenanceLogPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "table_maintenance_log" */
export enum TableMaintenanceLogSelectColumn {
  /** column name */
  DETAIL = "detail",
  /** column name */
  ID = "id",
  /** column name */
  LOGGED_AT = "logged_at",
  /** column name */
  OPERATION = "operation",
}

/** input type for updating data in table "table_maintenance_log" */
export type TableMaintenanceLogSetInput = {
  detail?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  logged_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  operation?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type TableMaintenanceLogStddevFields = {
  __typename?: "table_maintenance_log_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type TableMaintenanceLogStddevPopFields = {
  __typename?: "table_maintenance_log_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type TableMaintenanceLogStddevSampFields = {
  __typename?: "table_maintenance_log_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "table_maintenance_log" */
export type TableMaintenanceLogStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: TableMaintenanceLogStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type TableMaintenanceLogStreamCursorValueInput = {
  detail?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  logged_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  operation?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type TableMaintenanceLogSumFields = {
  __typename?: "table_maintenance_log_sum_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "table_maintenance_log" */
export enum TableMaintenanceLogUpdateColumn {
  /** column name */
  DETAIL = "detail",
  /** column name */
  ID = "id",
  /** column name */
  LOGGED_AT = "logged_at",
  /** column name */
  OPERATION = "operation",
}

export type TableMaintenanceLogUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<TableMaintenanceLogIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<TableMaintenanceLogSetInput>;
  /** filter the rows which have to be updated */
  where: TableMaintenanceLogBoolExp;
};

/** aggregate var_pop on columns */
export type TableMaintenanceLogVarPopFields = {
  __typename?: "table_maintenance_log_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type TableMaintenanceLogVarSampFields = {
  __typename?: "table_maintenance_log_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type TableMaintenanceLogVarianceFields = {
  __typename?: "table_maintenance_log_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "table_query_performance" */
export type TableQueryPerformance = {
  __typename?: "table_query_performance";
  avg_duration?: Maybe<Scalars["interval"]["output"]>;
  capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  execution_count?: Maybe<Scalars["bigint"]["output"]>;
  query?: Maybe<Scalars["String"]["output"]>;
};

/** aggregated selection of "table_query_performance" */
export type TableQueryPerformanceAggregate = {
  __typename?: "table_query_performance_aggregate";
  aggregate?: Maybe<TableQueryPerformanceAggregateFields>;
  nodes: Array<TableQueryPerformance>;
};

/** aggregate fields of "table_query_performance" */
export type TableQueryPerformanceAggregateFields = {
  __typename?: "table_query_performance_aggregate_fields";
  avg?: Maybe<TableQueryPerformanceAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<TableQueryPerformanceMaxFields>;
  min?: Maybe<TableQueryPerformanceMinFields>;
  stddev?: Maybe<TableQueryPerformanceStddevFields>;
  stddev_pop?: Maybe<TableQueryPerformanceStddevPopFields>;
  stddev_samp?: Maybe<TableQueryPerformanceStddevSampFields>;
  sum?: Maybe<TableQueryPerformanceSumFields>;
  var_pop?: Maybe<TableQueryPerformanceVarPopFields>;
  var_samp?: Maybe<TableQueryPerformanceVarSampFields>;
  variance?: Maybe<TableQueryPerformanceVarianceFields>;
};

/** aggregate fields of "table_query_performance" */
export type TableQueryPerformanceAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<TableQueryPerformanceSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type TableQueryPerformanceAvgFields = {
  __typename?: "table_query_performance_avg_fields";
  execution_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "table_query_performance". All fields are combined with a logical 'AND'. */
export type TableQueryPerformanceBoolExp = {
  _and?: InputMaybe<Array<TableQueryPerformanceBoolExp>>;
  _not?: InputMaybe<TableQueryPerformanceBoolExp>;
  _or?: InputMaybe<Array<TableQueryPerformanceBoolExp>>;
  avg_duration?: InputMaybe<IntervalComparisonExp>;
  capture_time?: InputMaybe<TimestamptzComparisonExp>;
  execution_count?: InputMaybe<BigintComparisonExp>;
  query?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "table_query_performance" */
export enum TableQueryPerformanceConstraint {
  /** unique or primary key constraint on columns "query", "capture_time" */
  IDX_QUERY_PERFORMANCE_UNIQUE = "idx_query_performance_unique",
}

/** input type for incrementing numeric columns in table "table_query_performance" */
export type TableQueryPerformanceIncInput = {
  execution_count?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** input type for inserting data into table "table_query_performance" */
export type TableQueryPerformanceInsertInput = {
  avg_duration?: InputMaybe<Scalars["interval"]["input"]>;
  capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  execution_count?: InputMaybe<Scalars["bigint"]["input"]>;
  query?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type TableQueryPerformanceMaxFields = {
  __typename?: "table_query_performance_max_fields";
  capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  execution_count?: Maybe<Scalars["bigint"]["output"]>;
  query?: Maybe<Scalars["String"]["output"]>;
};

/** aggregate min on columns */
export type TableQueryPerformanceMinFields = {
  __typename?: "table_query_performance_min_fields";
  capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  execution_count?: Maybe<Scalars["bigint"]["output"]>;
  query?: Maybe<Scalars["String"]["output"]>;
};

/** response of any mutation on the table "table_query_performance" */
export type TableQueryPerformanceMutationResponse = {
  __typename?: "table_query_performance_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<TableQueryPerformance>;
};

/** on_conflict condition type for table "table_query_performance" */
export type TableQueryPerformanceOnConflict = {
  constraint: TableQueryPerformanceConstraint;
  update_columns?: Array<TableQueryPerformanceUpdateColumn>;
  where?: InputMaybe<TableQueryPerformanceBoolExp>;
};

/** Ordering options when selecting data from "table_query_performance". */
export type TableQueryPerformanceOrderBy = {
  avg_duration?: InputMaybe<OrderBy>;
  capture_time?: InputMaybe<OrderBy>;
  execution_count?: InputMaybe<OrderBy>;
  query?: InputMaybe<OrderBy>;
};

/** select columns of table "table_query_performance" */
export enum TableQueryPerformanceSelectColumn {
  /** column name */
  AVG_DURATION = "avg_duration",
  /** column name */
  CAPTURE_TIME = "capture_time",
  /** column name */
  EXECUTION_COUNT = "execution_count",
  /** column name */
  QUERY = "query",
}

/** input type for updating data in table "table_query_performance" */
export type TableQueryPerformanceSetInput = {
  avg_duration?: InputMaybe<Scalars["interval"]["input"]>;
  capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  execution_count?: InputMaybe<Scalars["bigint"]["input"]>;
  query?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type TableQueryPerformanceStddevFields = {
  __typename?: "table_query_performance_stddev_fields";
  execution_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type TableQueryPerformanceStddevPopFields = {
  __typename?: "table_query_performance_stddev_pop_fields";
  execution_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type TableQueryPerformanceStddevSampFields = {
  __typename?: "table_query_performance_stddev_samp_fields";
  execution_count?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "table_query_performance" */
export type TableQueryPerformanceStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: TableQueryPerformanceStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type TableQueryPerformanceStreamCursorValueInput = {
  avg_duration?: InputMaybe<Scalars["interval"]["input"]>;
  capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  execution_count?: InputMaybe<Scalars["bigint"]["input"]>;
  query?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type TableQueryPerformanceSumFields = {
  __typename?: "table_query_performance_sum_fields";
  execution_count?: Maybe<Scalars["bigint"]["output"]>;
};

/** update columns of table "table_query_performance" */
export enum TableQueryPerformanceUpdateColumn {
  /** column name */
  AVG_DURATION = "avg_duration",
  /** column name */
  CAPTURE_TIME = "capture_time",
  /** column name */
  EXECUTION_COUNT = "execution_count",
  /** column name */
  QUERY = "query",
}

export type TableQueryPerformanceUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<TableQueryPerformanceIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<TableQueryPerformanceSetInput>;
  /** filter the rows which have to be updated */
  where: TableQueryPerformanceBoolExp;
};

/** aggregate var_pop on columns */
export type TableQueryPerformanceVarPopFields = {
  __typename?: "table_query_performance_var_pop_fields";
  execution_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type TableQueryPerformanceVarSampFields = {
  __typename?: "table_query_performance_var_samp_fields";
  execution_count?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type TableQueryPerformanceVarianceFields = {
  __typename?: "table_query_performance_variance_fields";
  execution_count?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "table_sequence_usage" */
export type TableSequenceUsage = {
  __typename?: "table_sequence_usage";
  capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  current_value?: Maybe<Scalars["bigint"]["output"]>;
  max_value?: Maybe<Scalars["bigint"]["output"]>;
  sequence_name?: Maybe<Scalars["String"]["output"]>;
};

/** aggregated selection of "table_sequence_usage" */
export type TableSequenceUsageAggregate = {
  __typename?: "table_sequence_usage_aggregate";
  aggregate?: Maybe<TableSequenceUsageAggregateFields>;
  nodes: Array<TableSequenceUsage>;
};

/** aggregate fields of "table_sequence_usage" */
export type TableSequenceUsageAggregateFields = {
  __typename?: "table_sequence_usage_aggregate_fields";
  avg?: Maybe<TableSequenceUsageAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<TableSequenceUsageMaxFields>;
  min?: Maybe<TableSequenceUsageMinFields>;
  stddev?: Maybe<TableSequenceUsageStddevFields>;
  stddev_pop?: Maybe<TableSequenceUsageStddevPopFields>;
  stddev_samp?: Maybe<TableSequenceUsageStddevSampFields>;
  sum?: Maybe<TableSequenceUsageSumFields>;
  var_pop?: Maybe<TableSequenceUsageVarPopFields>;
  var_samp?: Maybe<TableSequenceUsageVarSampFields>;
  variance?: Maybe<TableSequenceUsageVarianceFields>;
};

/** aggregate fields of "table_sequence_usage" */
export type TableSequenceUsageAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<TableSequenceUsageSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type TableSequenceUsageAvgFields = {
  __typename?: "table_sequence_usage_avg_fields";
  current_value?: Maybe<Scalars["Float"]["output"]>;
  max_value?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "table_sequence_usage". All fields are combined with a logical 'AND'. */
export type TableSequenceUsageBoolExp = {
  _and?: InputMaybe<Array<TableSequenceUsageBoolExp>>;
  _not?: InputMaybe<TableSequenceUsageBoolExp>;
  _or?: InputMaybe<Array<TableSequenceUsageBoolExp>>;
  capture_time?: InputMaybe<TimestamptzComparisonExp>;
  current_value?: InputMaybe<BigintComparisonExp>;
  max_value?: InputMaybe<BigintComparisonExp>;
  sequence_name?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "table_sequence_usage" */
export enum TableSequenceUsageConstraint {
  /** unique or primary key constraint on columns "capture_time", "sequence_name" */
  IDX_SEQUENCE_USAGE_UNIQUE = "idx_sequence_usage_unique",
}

/** input type for incrementing numeric columns in table "table_sequence_usage" */
export type TableSequenceUsageIncInput = {
  current_value?: InputMaybe<Scalars["bigint"]["input"]>;
  max_value?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** input type for inserting data into table "table_sequence_usage" */
export type TableSequenceUsageInsertInput = {
  capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  current_value?: InputMaybe<Scalars["bigint"]["input"]>;
  max_value?: InputMaybe<Scalars["bigint"]["input"]>;
  sequence_name?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type TableSequenceUsageMaxFields = {
  __typename?: "table_sequence_usage_max_fields";
  capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  current_value?: Maybe<Scalars["bigint"]["output"]>;
  max_value?: Maybe<Scalars["bigint"]["output"]>;
  sequence_name?: Maybe<Scalars["String"]["output"]>;
};

/** aggregate min on columns */
export type TableSequenceUsageMinFields = {
  __typename?: "table_sequence_usage_min_fields";
  capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  current_value?: Maybe<Scalars["bigint"]["output"]>;
  max_value?: Maybe<Scalars["bigint"]["output"]>;
  sequence_name?: Maybe<Scalars["String"]["output"]>;
};

/** response of any mutation on the table "table_sequence_usage" */
export type TableSequenceUsageMutationResponse = {
  __typename?: "table_sequence_usage_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<TableSequenceUsage>;
};

/** on_conflict condition type for table "table_sequence_usage" */
export type TableSequenceUsageOnConflict = {
  constraint: TableSequenceUsageConstraint;
  update_columns?: Array<TableSequenceUsageUpdateColumn>;
  where?: InputMaybe<TableSequenceUsageBoolExp>;
};

/** Ordering options when selecting data from "table_sequence_usage". */
export type TableSequenceUsageOrderBy = {
  capture_time?: InputMaybe<OrderBy>;
  current_value?: InputMaybe<OrderBy>;
  max_value?: InputMaybe<OrderBy>;
  sequence_name?: InputMaybe<OrderBy>;
};

/** select columns of table "table_sequence_usage" */
export enum TableSequenceUsageSelectColumn {
  /** column name */
  CAPTURE_TIME = "capture_time",
  /** column name */
  CURRENT_VALUE = "current_value",
  /** column name */
  MAX_VALUE = "max_value",
  /** column name */
  SEQUENCE_NAME = "sequence_name",
}

/** input type for updating data in table "table_sequence_usage" */
export type TableSequenceUsageSetInput = {
  capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  current_value?: InputMaybe<Scalars["bigint"]["input"]>;
  max_value?: InputMaybe<Scalars["bigint"]["input"]>;
  sequence_name?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type TableSequenceUsageStddevFields = {
  __typename?: "table_sequence_usage_stddev_fields";
  current_value?: Maybe<Scalars["Float"]["output"]>;
  max_value?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type TableSequenceUsageStddevPopFields = {
  __typename?: "table_sequence_usage_stddev_pop_fields";
  current_value?: Maybe<Scalars["Float"]["output"]>;
  max_value?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type TableSequenceUsageStddevSampFields = {
  __typename?: "table_sequence_usage_stddev_samp_fields";
  current_value?: Maybe<Scalars["Float"]["output"]>;
  max_value?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "table_sequence_usage" */
export type TableSequenceUsageStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: TableSequenceUsageStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type TableSequenceUsageStreamCursorValueInput = {
  capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  current_value?: InputMaybe<Scalars["bigint"]["input"]>;
  max_value?: InputMaybe<Scalars["bigint"]["input"]>;
  sequence_name?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type TableSequenceUsageSumFields = {
  __typename?: "table_sequence_usage_sum_fields";
  current_value?: Maybe<Scalars["bigint"]["output"]>;
  max_value?: Maybe<Scalars["bigint"]["output"]>;
};

/** update columns of table "table_sequence_usage" */
export enum TableSequenceUsageUpdateColumn {
  /** column name */
  CAPTURE_TIME = "capture_time",
  /** column name */
  CURRENT_VALUE = "current_value",
  /** column name */
  MAX_VALUE = "max_value",
  /** column name */
  SEQUENCE_NAME = "sequence_name",
}

export type TableSequenceUsageUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<TableSequenceUsageIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<TableSequenceUsageSetInput>;
  /** filter the rows which have to be updated */
  where: TableSequenceUsageBoolExp;
};

/** aggregate var_pop on columns */
export type TableSequenceUsageVarPopFields = {
  __typename?: "table_sequence_usage_var_pop_fields";
  current_value?: Maybe<Scalars["Float"]["output"]>;
  max_value?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type TableSequenceUsageVarSampFields = {
  __typename?: "table_sequence_usage_var_samp_fields";
  current_value?: Maybe<Scalars["Float"]["output"]>;
  max_value?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type TableSequenceUsageVarianceFields = {
  __typename?: "table_sequence_usage_variance_fields";
  current_value?: Maybe<Scalars["Float"]["output"]>;
  max_value?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "table_statistics" */
export type TableStatistics = {
  __typename?: "table_statistics";
  buffer_cache_hit_ratio?: Maybe<Scalars["float8"]["output"]>;
  capture_time: Scalars["timestamptz"]["output"];
  dead_tuples?: Maybe<Scalars["bigint"]["output"]>;
  estimated_bloat_ratio?: Maybe<Scalars["float8"]["output"]>;
  index_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  index_size?: Maybe<Scalars["bigint"]["output"]>;
  index_usage?: Maybe<Scalars["jsonb"]["output"]>;
  last_analyze?: Maybe<Scalars["timestamptz"]["output"]>;
  last_vacuum?: Maybe<Scalars["timestamptz"]["output"]>;
  live_tuples?: Maybe<Scalars["bigint"]["output"]>;
  row_count?: Maybe<Scalars["bigint"]["output"]>;
  seq_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  table_name: Scalars["String"]["output"];
  table_size?: Maybe<Scalars["bigint"]["output"]>;
};

/** columns and relationships of "table_statistics" */
export type TableStatisticsIndexUsageArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "table_statistics" */
export type TableStatisticsAggregate = {
  __typename?: "table_statistics_aggregate";
  aggregate?: Maybe<TableStatisticsAggregateFields>;
  nodes: Array<TableStatistics>;
};

/** aggregate fields of "table_statistics" */
export type TableStatisticsAggregateFields = {
  __typename?: "table_statistics_aggregate_fields";
  avg?: Maybe<TableStatisticsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<TableStatisticsMaxFields>;
  min?: Maybe<TableStatisticsMinFields>;
  stddev?: Maybe<TableStatisticsStddevFields>;
  stddev_pop?: Maybe<TableStatisticsStddevPopFields>;
  stddev_samp?: Maybe<TableStatisticsStddevSampFields>;
  sum?: Maybe<TableStatisticsSumFields>;
  var_pop?: Maybe<TableStatisticsVarPopFields>;
  var_samp?: Maybe<TableStatisticsVarSampFields>;
  variance?: Maybe<TableStatisticsVarianceFields>;
};

/** aggregate fields of "table_statistics" */
export type TableStatisticsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<TableStatisticsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type TableStatisticsAppendInput = {
  index_usage?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** aggregate avg on columns */
export type TableStatisticsAvgFields = {
  __typename?: "table_statistics_avg_fields";
  buffer_cache_hit_ratio?: Maybe<Scalars["Float"]["output"]>;
  dead_tuples?: Maybe<Scalars["Float"]["output"]>;
  estimated_bloat_ratio?: Maybe<Scalars["Float"]["output"]>;
  index_scan_count?: Maybe<Scalars["Float"]["output"]>;
  index_size?: Maybe<Scalars["Float"]["output"]>;
  live_tuples?: Maybe<Scalars["Float"]["output"]>;
  row_count?: Maybe<Scalars["Float"]["output"]>;
  seq_scan_count?: Maybe<Scalars["Float"]["output"]>;
  table_size?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "table_statistics". All fields are combined with a logical 'AND'. */
export type TableStatisticsBoolExp = {
  _and?: InputMaybe<Array<TableStatisticsBoolExp>>;
  _not?: InputMaybe<TableStatisticsBoolExp>;
  _or?: InputMaybe<Array<TableStatisticsBoolExp>>;
  buffer_cache_hit_ratio?: InputMaybe<Float8ComparisonExp>;
  capture_time?: InputMaybe<TimestamptzComparisonExp>;
  dead_tuples?: InputMaybe<BigintComparisonExp>;
  estimated_bloat_ratio?: InputMaybe<Float8ComparisonExp>;
  index_scan_count?: InputMaybe<BigintComparisonExp>;
  index_size?: InputMaybe<BigintComparisonExp>;
  index_usage?: InputMaybe<JsonbComparisonExp>;
  last_analyze?: InputMaybe<TimestamptzComparisonExp>;
  last_vacuum?: InputMaybe<TimestamptzComparisonExp>;
  live_tuples?: InputMaybe<BigintComparisonExp>;
  row_count?: InputMaybe<BigintComparisonExp>;
  seq_scan_count?: InputMaybe<BigintComparisonExp>;
  table_name?: InputMaybe<StringComparisonExp>;
  table_size?: InputMaybe<BigintComparisonExp>;
};

/** unique or primary key constraints on table "table_statistics" */
export enum TableStatisticsConstraint {
  /** unique or primary key constraint on columns "capture_time", "table_name" */
  TABLE_STATISTICS_PKEY = "table_statistics_pkey",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type TableStatisticsDeleteAtPathInput = {
  index_usage?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type TableStatisticsDeleteElemInput = {
  index_usage?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type TableStatisticsDeleteKeyInput = {
  index_usage?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for incrementing numeric columns in table "table_statistics" */
export type TableStatisticsIncInput = {
  buffer_cache_hit_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  dead_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  estimated_bloat_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  index_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  index_size?: InputMaybe<Scalars["bigint"]["input"]>;
  live_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  row_count?: InputMaybe<Scalars["bigint"]["input"]>;
  seq_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  table_size?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** input type for inserting data into table "table_statistics" */
export type TableStatisticsInsertInput = {
  buffer_cache_hit_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  dead_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  estimated_bloat_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  index_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  index_size?: InputMaybe<Scalars["bigint"]["input"]>;
  index_usage?: InputMaybe<Scalars["jsonb"]["input"]>;
  last_analyze?: InputMaybe<Scalars["timestamptz"]["input"]>;
  last_vacuum?: InputMaybe<Scalars["timestamptz"]["input"]>;
  live_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  row_count?: InputMaybe<Scalars["bigint"]["input"]>;
  seq_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  table_name?: InputMaybe<Scalars["String"]["input"]>;
  table_size?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** aggregate max on columns */
export type TableStatisticsMaxFields = {
  __typename?: "table_statistics_max_fields";
  buffer_cache_hit_ratio?: Maybe<Scalars["float8"]["output"]>;
  capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  dead_tuples?: Maybe<Scalars["bigint"]["output"]>;
  estimated_bloat_ratio?: Maybe<Scalars["float8"]["output"]>;
  index_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  index_size?: Maybe<Scalars["bigint"]["output"]>;
  last_analyze?: Maybe<Scalars["timestamptz"]["output"]>;
  last_vacuum?: Maybe<Scalars["timestamptz"]["output"]>;
  live_tuples?: Maybe<Scalars["bigint"]["output"]>;
  row_count?: Maybe<Scalars["bigint"]["output"]>;
  seq_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  table_name?: Maybe<Scalars["String"]["output"]>;
  table_size?: Maybe<Scalars["bigint"]["output"]>;
};

/** aggregate min on columns */
export type TableStatisticsMinFields = {
  __typename?: "table_statistics_min_fields";
  buffer_cache_hit_ratio?: Maybe<Scalars["float8"]["output"]>;
  capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  dead_tuples?: Maybe<Scalars["bigint"]["output"]>;
  estimated_bloat_ratio?: Maybe<Scalars["float8"]["output"]>;
  index_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  index_size?: Maybe<Scalars["bigint"]["output"]>;
  last_analyze?: Maybe<Scalars["timestamptz"]["output"]>;
  last_vacuum?: Maybe<Scalars["timestamptz"]["output"]>;
  live_tuples?: Maybe<Scalars["bigint"]["output"]>;
  row_count?: Maybe<Scalars["bigint"]["output"]>;
  seq_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  table_name?: Maybe<Scalars["String"]["output"]>;
  table_size?: Maybe<Scalars["bigint"]["output"]>;
};

/** response of any mutation on the table "table_statistics" */
export type TableStatisticsMutationResponse = {
  __typename?: "table_statistics_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<TableStatistics>;
};

/** on_conflict condition type for table "table_statistics" */
export type TableStatisticsOnConflict = {
  constraint: TableStatisticsConstraint;
  update_columns?: Array<TableStatisticsUpdateColumn>;
  where?: InputMaybe<TableStatisticsBoolExp>;
};

/** Ordering options when selecting data from "table_statistics". */
export type TableStatisticsOrderBy = {
  buffer_cache_hit_ratio?: InputMaybe<OrderBy>;
  capture_time?: InputMaybe<OrderBy>;
  dead_tuples?: InputMaybe<OrderBy>;
  estimated_bloat_ratio?: InputMaybe<OrderBy>;
  index_scan_count?: InputMaybe<OrderBy>;
  index_size?: InputMaybe<OrderBy>;
  index_usage?: InputMaybe<OrderBy>;
  last_analyze?: InputMaybe<OrderBy>;
  last_vacuum?: InputMaybe<OrderBy>;
  live_tuples?: InputMaybe<OrderBy>;
  row_count?: InputMaybe<OrderBy>;
  seq_scan_count?: InputMaybe<OrderBy>;
  table_name?: InputMaybe<OrderBy>;
  table_size?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: table_statistics */
export type TableStatisticsPkColumnsInput = {
  capture_time: Scalars["timestamptz"]["input"];
  table_name: Scalars["String"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type TableStatisticsPrependInput = {
  index_usage?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "table_statistics" */
export enum TableStatisticsSelectColumn {
  /** column name */
  BUFFER_CACHE_HIT_RATIO = "buffer_cache_hit_ratio",
  /** column name */
  CAPTURE_TIME = "capture_time",
  /** column name */
  DEAD_TUPLES = "dead_tuples",
  /** column name */
  ESTIMATED_BLOAT_RATIO = "estimated_bloat_ratio",
  /** column name */
  INDEX_SCAN_COUNT = "index_scan_count",
  /** column name */
  INDEX_SIZE = "index_size",
  /** column name */
  INDEX_USAGE = "index_usage",
  /** column name */
  LAST_ANALYZE = "last_analyze",
  /** column name */
  LAST_VACUUM = "last_vacuum",
  /** column name */
  LIVE_TUPLES = "live_tuples",
  /** column name */
  ROW_COUNT = "row_count",
  /** column name */
  SEQ_SCAN_COUNT = "seq_scan_count",
  /** column name */
  TABLE_NAME = "table_name",
  /** column name */
  TABLE_SIZE = "table_size",
}

/** input type for updating data in table "table_statistics" */
export type TableStatisticsSetInput = {
  buffer_cache_hit_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  dead_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  estimated_bloat_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  index_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  index_size?: InputMaybe<Scalars["bigint"]["input"]>;
  index_usage?: InputMaybe<Scalars["jsonb"]["input"]>;
  last_analyze?: InputMaybe<Scalars["timestamptz"]["input"]>;
  last_vacuum?: InputMaybe<Scalars["timestamptz"]["input"]>;
  live_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  row_count?: InputMaybe<Scalars["bigint"]["input"]>;
  seq_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  table_name?: InputMaybe<Scalars["String"]["input"]>;
  table_size?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** aggregate stddev on columns */
export type TableStatisticsStddevFields = {
  __typename?: "table_statistics_stddev_fields";
  buffer_cache_hit_ratio?: Maybe<Scalars["Float"]["output"]>;
  dead_tuples?: Maybe<Scalars["Float"]["output"]>;
  estimated_bloat_ratio?: Maybe<Scalars["Float"]["output"]>;
  index_scan_count?: Maybe<Scalars["Float"]["output"]>;
  index_size?: Maybe<Scalars["Float"]["output"]>;
  live_tuples?: Maybe<Scalars["Float"]["output"]>;
  row_count?: Maybe<Scalars["Float"]["output"]>;
  seq_scan_count?: Maybe<Scalars["Float"]["output"]>;
  table_size?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type TableStatisticsStddevPopFields = {
  __typename?: "table_statistics_stddev_pop_fields";
  buffer_cache_hit_ratio?: Maybe<Scalars["Float"]["output"]>;
  dead_tuples?: Maybe<Scalars["Float"]["output"]>;
  estimated_bloat_ratio?: Maybe<Scalars["Float"]["output"]>;
  index_scan_count?: Maybe<Scalars["Float"]["output"]>;
  index_size?: Maybe<Scalars["Float"]["output"]>;
  live_tuples?: Maybe<Scalars["Float"]["output"]>;
  row_count?: Maybe<Scalars["Float"]["output"]>;
  seq_scan_count?: Maybe<Scalars["Float"]["output"]>;
  table_size?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type TableStatisticsStddevSampFields = {
  __typename?: "table_statistics_stddev_samp_fields";
  buffer_cache_hit_ratio?: Maybe<Scalars["Float"]["output"]>;
  dead_tuples?: Maybe<Scalars["Float"]["output"]>;
  estimated_bloat_ratio?: Maybe<Scalars["Float"]["output"]>;
  index_scan_count?: Maybe<Scalars["Float"]["output"]>;
  index_size?: Maybe<Scalars["Float"]["output"]>;
  live_tuples?: Maybe<Scalars["Float"]["output"]>;
  row_count?: Maybe<Scalars["Float"]["output"]>;
  seq_scan_count?: Maybe<Scalars["Float"]["output"]>;
  table_size?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "table_statistics" */
export type TableStatisticsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: TableStatisticsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type TableStatisticsStreamCursorValueInput = {
  buffer_cache_hit_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  dead_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  estimated_bloat_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  index_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  index_size?: InputMaybe<Scalars["bigint"]["input"]>;
  index_usage?: InputMaybe<Scalars["jsonb"]["input"]>;
  last_analyze?: InputMaybe<Scalars["timestamptz"]["input"]>;
  last_vacuum?: InputMaybe<Scalars["timestamptz"]["input"]>;
  live_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  row_count?: InputMaybe<Scalars["bigint"]["input"]>;
  seq_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  table_name?: InputMaybe<Scalars["String"]["input"]>;
  table_size?: InputMaybe<Scalars["bigint"]["input"]>;
};

/** aggregate sum on columns */
export type TableStatisticsSumFields = {
  __typename?: "table_statistics_sum_fields";
  buffer_cache_hit_ratio?: Maybe<Scalars["float8"]["output"]>;
  dead_tuples?: Maybe<Scalars["bigint"]["output"]>;
  estimated_bloat_ratio?: Maybe<Scalars["float8"]["output"]>;
  index_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  index_size?: Maybe<Scalars["bigint"]["output"]>;
  live_tuples?: Maybe<Scalars["bigint"]["output"]>;
  row_count?: Maybe<Scalars["bigint"]["output"]>;
  seq_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  table_size?: Maybe<Scalars["bigint"]["output"]>;
};

/** update columns of table "table_statistics" */
export enum TableStatisticsUpdateColumn {
  /** column name */
  BUFFER_CACHE_HIT_RATIO = "buffer_cache_hit_ratio",
  /** column name */
  CAPTURE_TIME = "capture_time",
  /** column name */
  DEAD_TUPLES = "dead_tuples",
  /** column name */
  ESTIMATED_BLOAT_RATIO = "estimated_bloat_ratio",
  /** column name */
  INDEX_SCAN_COUNT = "index_scan_count",
  /** column name */
  INDEX_SIZE = "index_size",
  /** column name */
  INDEX_USAGE = "index_usage",
  /** column name */
  LAST_ANALYZE = "last_analyze",
  /** column name */
  LAST_VACUUM = "last_vacuum",
  /** column name */
  LIVE_TUPLES = "live_tuples",
  /** column name */
  ROW_COUNT = "row_count",
  /** column name */
  SEQ_SCAN_COUNT = "seq_scan_count",
  /** column name */
  TABLE_NAME = "table_name",
  /** column name */
  TABLE_SIZE = "table_size",
}

export type TableStatisticsUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<TableStatisticsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<TableStatisticsDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<TableStatisticsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<TableStatisticsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<TableStatisticsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<TableStatisticsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<TableStatisticsSetInput>;
  /** filter the rows which have to be updated */
  where: TableStatisticsBoolExp;
};

/** aggregate var_pop on columns */
export type TableStatisticsVarPopFields = {
  __typename?: "table_statistics_var_pop_fields";
  buffer_cache_hit_ratio?: Maybe<Scalars["Float"]["output"]>;
  dead_tuples?: Maybe<Scalars["Float"]["output"]>;
  estimated_bloat_ratio?: Maybe<Scalars["Float"]["output"]>;
  index_scan_count?: Maybe<Scalars["Float"]["output"]>;
  index_size?: Maybe<Scalars["Float"]["output"]>;
  live_tuples?: Maybe<Scalars["Float"]["output"]>;
  row_count?: Maybe<Scalars["Float"]["output"]>;
  seq_scan_count?: Maybe<Scalars["Float"]["output"]>;
  table_size?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type TableStatisticsVarSampFields = {
  __typename?: "table_statistics_var_samp_fields";
  buffer_cache_hit_ratio?: Maybe<Scalars["Float"]["output"]>;
  dead_tuples?: Maybe<Scalars["Float"]["output"]>;
  estimated_bloat_ratio?: Maybe<Scalars["Float"]["output"]>;
  index_scan_count?: Maybe<Scalars["Float"]["output"]>;
  index_size?: Maybe<Scalars["Float"]["output"]>;
  live_tuples?: Maybe<Scalars["Float"]["output"]>;
  row_count?: Maybe<Scalars["Float"]["output"]>;
  seq_scan_count?: Maybe<Scalars["Float"]["output"]>;
  table_size?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type TableStatisticsVarianceFields = {
  __typename?: "table_statistics_variance_fields";
  buffer_cache_hit_ratio?: Maybe<Scalars["Float"]["output"]>;
  dead_tuples?: Maybe<Scalars["Float"]["output"]>;
  estimated_bloat_ratio?: Maybe<Scalars["Float"]["output"]>;
  index_scan_count?: Maybe<Scalars["Float"]["output"]>;
  index_size?: Maybe<Scalars["Float"]["output"]>;
  live_tuples?: Maybe<Scalars["Float"]["output"]>;
  row_count?: Maybe<Scalars["Float"]["output"]>;
  seq_scan_count?: Maybe<Scalars["Float"]["output"]>;
  table_size?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "tags" */
export type Tags = {
  __typename?: "tags";
  body?: Maybe<Scalars["String"]["output"]>;
  /** An array relationship */
  content_tags: Array<ContentTags>;
  /** An aggregate relationship */
  content_tags_aggregate: ContentTagsAggregate;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  document_id?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["Int"]["output"];
  locale?: Maybe<Scalars["String"]["output"]>;
  name: Scalars["String"]["output"];
  /** An array relationship */
  news_tags: Array<NewsTags>;
  /** An aggregate relationship */
  news_tags_aggregate: NewsTagsAggregate;
  published_at?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** columns and relationships of "tags" */
export type TagsContentTagsArgs = {
  distinct_on?: InputMaybe<Array<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentTagsOrderBy>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

/** columns and relationships of "tags" */
export type TagsContentTagsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentTagsOrderBy>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

/** columns and relationships of "tags" */
export type TagsNewsTagsArgs = {
  distinct_on?: InputMaybe<Array<NewsTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsTagsOrderBy>>;
  where?: InputMaybe<NewsTagsBoolExp>;
};

/** columns and relationships of "tags" */
export type TagsNewsTagsAggregateArgs = {
  distinct_on?: InputMaybe<Array<NewsTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsTagsOrderBy>>;
  where?: InputMaybe<NewsTagsBoolExp>;
};

/** aggregated selection of "tags" */
export type TagsAggregate = {
  __typename?: "tags_aggregate";
  aggregate?: Maybe<TagsAggregateFields>;
  nodes: Array<Tags>;
};

/** aggregate fields of "tags" */
export type TagsAggregateFields = {
  __typename?: "tags_aggregate_fields";
  avg?: Maybe<TagsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<TagsMaxFields>;
  min?: Maybe<TagsMinFields>;
  stddev?: Maybe<TagsStddevFields>;
  stddev_pop?: Maybe<TagsStddevPopFields>;
  stddev_samp?: Maybe<TagsStddevSampFields>;
  sum?: Maybe<TagsSumFields>;
  var_pop?: Maybe<TagsVarPopFields>;
  var_samp?: Maybe<TagsVarSampFields>;
  variance?: Maybe<TagsVarianceFields>;
};

/** aggregate fields of "tags" */
export type TagsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<TagsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type TagsAvgFields = {
  __typename?: "tags_avg_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "tags". All fields are combined with a logical 'AND'. */
export type TagsBoolExp = {
  _and?: InputMaybe<Array<TagsBoolExp>>;
  _not?: InputMaybe<TagsBoolExp>;
  _or?: InputMaybe<Array<TagsBoolExp>>;
  body?: InputMaybe<StringComparisonExp>;
  content_tags?: InputMaybe<ContentTagsBoolExp>;
  content_tags_aggregate?: InputMaybe<ContentTagsAggregateBoolExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  document_id?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<IntComparisonExp>;
  locale?: InputMaybe<StringComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  news_tags?: InputMaybe<NewsTagsBoolExp>;
  news_tags_aggregate?: InputMaybe<NewsTagsAggregateBoolExp>;
  published_at?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
};

/** unique or primary key constraints on table "tags" */
export enum TagsConstraint {
  /** unique or primary key constraint on columns "name" */
  TAGS_NAME_KEY = "tags_name_key",
  /** unique or primary key constraint on columns "id" */
  TAGS_PKEY = "tags_pkey",
}

/** input type for incrementing numeric columns in table "tags" */
export type TagsIncInput = {
  id?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "tags" */
export type TagsInsertInput = {
  body?: InputMaybe<Scalars["String"]["input"]>;
  content_tags?: InputMaybe<ContentTagsArrRelInsertInput>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  document_id?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  locale?: InputMaybe<Scalars["String"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  news_tags?: InputMaybe<NewsTagsArrRelInsertInput>;
  published_at?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate max on columns */
export type TagsMaxFields = {
  __typename?: "tags_max_fields";
  body?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  document_id?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  locale?: Maybe<Scalars["String"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  published_at?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregate min on columns */
export type TagsMinFields = {
  __typename?: "tags_min_fields";
  body?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  document_id?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["Int"]["output"]>;
  locale?: Maybe<Scalars["String"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  published_at?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** response of any mutation on the table "tags" */
export type TagsMutationResponse = {
  __typename?: "tags_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Tags>;
};

/** input type for inserting object relation for remote table "tags" */
export type TagsObjRelInsertInput = {
  data: TagsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<TagsOnConflict>;
};

/** on_conflict condition type for table "tags" */
export type TagsOnConflict = {
  constraint: TagsConstraint;
  update_columns?: Array<TagsUpdateColumn>;
  where?: InputMaybe<TagsBoolExp>;
};

/** Ordering options when selecting data from "tags". */
export type TagsOrderBy = {
  body?: InputMaybe<OrderBy>;
  content_tags_aggregate?: InputMaybe<ContentTagsAggregateOrderBy>;
  created_at?: InputMaybe<OrderBy>;
  document_id?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  locale?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  news_tags_aggregate?: InputMaybe<NewsTagsAggregateOrderBy>;
  published_at?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: tags */
export type TagsPkColumnsInput = {
  id: Scalars["Int"]["input"];
};

/** select columns of table "tags" */
export enum TagsSelectColumn {
  /** column name */
  BODY = "body",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DOCUMENT_ID = "document_id",
  /** column name */
  ID = "id",
  /** column name */
  LOCALE = "locale",
  /** column name */
  NAME = "name",
  /** column name */
  PUBLISHED_AT = "published_at",
  /** column name */
  UPDATED_AT = "updated_at",
}

/** input type for updating data in table "tags" */
export type TagsSetInput = {
  body?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  document_id?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  locale?: InputMaybe<Scalars["String"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  published_at?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate stddev on columns */
export type TagsStddevFields = {
  __typename?: "tags_stddev_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type TagsStddevPopFields = {
  __typename?: "tags_stddev_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type TagsStddevSampFields = {
  __typename?: "tags_stddev_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "tags" */
export type TagsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: TagsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type TagsStreamCursorValueInput = {
  body?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  document_id?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["Int"]["input"]>;
  locale?: InputMaybe<Scalars["String"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  published_at?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate sum on columns */
export type TagsSumFields = {
  __typename?: "tags_sum_fields";
  id?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "tags" */
export enum TagsUpdateColumn {
  /** column name */
  BODY = "body",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DOCUMENT_ID = "document_id",
  /** column name */
  ID = "id",
  /** column name */
  LOCALE = "locale",
  /** column name */
  NAME = "name",
  /** column name */
  PUBLISHED_AT = "published_at",
  /** column name */
  UPDATED_AT = "updated_at",
}

export type TagsUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<TagsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<TagsSetInput>;
  /** filter the rows which have to be updated */
  where: TagsBoolExp;
};

/** aggregate var_pop on columns */
export type TagsVarPopFields = {
  __typename?: "tags_var_pop_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type TagsVarSampFields = {
  __typename?: "tags_var_samp_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type TagsVarianceFields = {
  __typename?: "tags_variance_fields";
  id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to compare columns of type "timestamp". All fields are combined with logical 'AND'. */
export type TimestampComparisonExp = {
  _eq?: InputMaybe<Scalars["timestamp"]["input"]>;
  _gt?: InputMaybe<Scalars["timestamp"]["input"]>;
  _gte?: InputMaybe<Scalars["timestamp"]["input"]>;
  _in?: InputMaybe<Array<Scalars["timestamp"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["timestamp"]["input"]>;
  _lte?: InputMaybe<Scalars["timestamp"]["input"]>;
  _neq?: InputMaybe<Scalars["timestamp"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["timestamp"]["input"]>>;
};

/** Boolean expression to compare columns of type "timestamptz". All fields are combined with logical 'AND'. */
export type TimestamptzComparisonExp = {
  _eq?: InputMaybe<Scalars["timestamptz"]["input"]>;
  _gt?: InputMaybe<Scalars["timestamptz"]["input"]>;
  _gte?: InputMaybe<Scalars["timestamptz"]["input"]>;
  _in?: InputMaybe<Array<Scalars["timestamptz"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["timestamptz"]["input"]>;
  _lte?: InputMaybe<Scalars["timestamptz"]["input"]>;
  _neq?: InputMaybe<Scalars["timestamptz"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["timestamptz"]["input"]>>;
};

/** columns and relationships of "user_metrics" */
export type UserMetrics = {
  __typename?: "user_metrics";
  achievements?: Maybe<Scalars["jsonb"]["output"]>;
  best_streak?: Maybe<Scalars["Int"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  current_level?: Maybe<Scalars["Int"]["output"]>;
  current_streak?: Maybe<Scalars["Int"]["output"]>;
  current_xp?: Maybe<Scalars["Int"]["output"]>;
  downvote_count?: Maybe<Scalars["Int"]["output"]>;
  id: Scalars["uuid"]["output"];
  interaction_stats?: Maybe<Scalars["jsonb"]["output"]>;
  last_vote_date?: Maybe<Scalars["timestamptz"]["output"]>;
  multipliers?: Maybe<Scalars["jsonb"]["output"]>;
  points?: Maybe<Scalars["Int"]["output"]>;
  points_breakdown?: Maybe<Scalars["jsonb"]["output"]>;
  titles?: Maybe<Scalars["jsonb"]["output"]>;
  today_vote_count?: Maybe<Scalars["Int"]["output"]>;
  total_reading_time?: Maybe<Scalars["Int"]["output"]>;
  total_votes?: Maybe<Scalars["Int"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  upvote_count?: Maybe<Scalars["Int"]["output"]>;
  user_id: Scalars["uuid"]["output"];
  /** An object relationship */
  user_profile: UserProfiles;
  vote_accuracy?: Maybe<Scalars["numeric"]["output"]>;
  xp_to_next_level?: Maybe<Scalars["Int"]["output"]>;
};

/** columns and relationships of "user_metrics" */
export type UserMetricsAchievementsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "user_metrics" */
export type UserMetricsInteractionStatsArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "user_metrics" */
export type UserMetricsMultipliersArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "user_metrics" */
export type UserMetricsPointsBreakdownArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** columns and relationships of "user_metrics" */
export type UserMetricsTitlesArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "user_metrics" */
export type UserMetricsAggregate = {
  __typename?: "user_metrics_aggregate";
  aggregate?: Maybe<UserMetricsAggregateFields>;
  nodes: Array<UserMetrics>;
};

/** aggregate fields of "user_metrics" */
export type UserMetricsAggregateFields = {
  __typename?: "user_metrics_aggregate_fields";
  avg?: Maybe<UserMetricsAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<UserMetricsMaxFields>;
  min?: Maybe<UserMetricsMinFields>;
  stddev?: Maybe<UserMetricsStddevFields>;
  stddev_pop?: Maybe<UserMetricsStddevPopFields>;
  stddev_samp?: Maybe<UserMetricsStddevSampFields>;
  sum?: Maybe<UserMetricsSumFields>;
  var_pop?: Maybe<UserMetricsVarPopFields>;
  var_samp?: Maybe<UserMetricsVarSampFields>;
  variance?: Maybe<UserMetricsVarianceFields>;
};

/** aggregate fields of "user_metrics" */
export type UserMetricsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<UserMetricsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type UserMetricsAppendInput = {
  achievements?: InputMaybe<Scalars["jsonb"]["input"]>;
  interaction_stats?: InputMaybe<Scalars["jsonb"]["input"]>;
  multipliers?: InputMaybe<Scalars["jsonb"]["input"]>;
  points_breakdown?: InputMaybe<Scalars["jsonb"]["input"]>;
  titles?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** aggregate avg on columns */
export type UserMetricsAvgFields = {
  __typename?: "user_metrics_avg_fields";
  best_streak?: Maybe<Scalars["Float"]["output"]>;
  current_level?: Maybe<Scalars["Float"]["output"]>;
  current_streak?: Maybe<Scalars["Float"]["output"]>;
  current_xp?: Maybe<Scalars["Float"]["output"]>;
  downvote_count?: Maybe<Scalars["Float"]["output"]>;
  points?: Maybe<Scalars["Float"]["output"]>;
  today_vote_count?: Maybe<Scalars["Float"]["output"]>;
  total_reading_time?: Maybe<Scalars["Float"]["output"]>;
  total_votes?: Maybe<Scalars["Float"]["output"]>;
  upvote_count?: Maybe<Scalars["Float"]["output"]>;
  vote_accuracy?: Maybe<Scalars["Float"]["output"]>;
  xp_to_next_level?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "user_metrics". All fields are combined with a logical 'AND'. */
export type UserMetricsBoolExp = {
  _and?: InputMaybe<Array<UserMetricsBoolExp>>;
  _not?: InputMaybe<UserMetricsBoolExp>;
  _or?: InputMaybe<Array<UserMetricsBoolExp>>;
  achievements?: InputMaybe<JsonbComparisonExp>;
  best_streak?: InputMaybe<IntComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  current_level?: InputMaybe<IntComparisonExp>;
  current_streak?: InputMaybe<IntComparisonExp>;
  current_xp?: InputMaybe<IntComparisonExp>;
  downvote_count?: InputMaybe<IntComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  interaction_stats?: InputMaybe<JsonbComparisonExp>;
  last_vote_date?: InputMaybe<TimestamptzComparisonExp>;
  multipliers?: InputMaybe<JsonbComparisonExp>;
  points?: InputMaybe<IntComparisonExp>;
  points_breakdown?: InputMaybe<JsonbComparisonExp>;
  titles?: InputMaybe<JsonbComparisonExp>;
  today_vote_count?: InputMaybe<IntComparisonExp>;
  total_reading_time?: InputMaybe<IntComparisonExp>;
  total_votes?: InputMaybe<IntComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  upvote_count?: InputMaybe<IntComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
  user_profile?: InputMaybe<UserProfilesBoolExp>;
  vote_accuracy?: InputMaybe<NumericComparisonExp>;
  xp_to_next_level?: InputMaybe<IntComparisonExp>;
};

/** unique or primary key constraints on table "user_metrics" */
export enum UserMetricsConstraint {
  /** unique or primary key constraint on columns "id" */
  USER_METRICS_PKEY = "user_metrics_pkey",
  /** unique or primary key constraint on columns "user_id" */
  USER_METRICS_USER_ID_KEY = "user_metrics_user_id_key",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type UserMetricsDeleteAtPathInput = {
  achievements?: InputMaybe<Array<Scalars["String"]["input"]>>;
  interaction_stats?: InputMaybe<Array<Scalars["String"]["input"]>>;
  multipliers?: InputMaybe<Array<Scalars["String"]["input"]>>;
  points_breakdown?: InputMaybe<Array<Scalars["String"]["input"]>>;
  titles?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type UserMetricsDeleteElemInput = {
  achievements?: InputMaybe<Scalars["Int"]["input"]>;
  interaction_stats?: InputMaybe<Scalars["Int"]["input"]>;
  multipliers?: InputMaybe<Scalars["Int"]["input"]>;
  points_breakdown?: InputMaybe<Scalars["Int"]["input"]>;
  titles?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type UserMetricsDeleteKeyInput = {
  achievements?: InputMaybe<Scalars["String"]["input"]>;
  interaction_stats?: InputMaybe<Scalars["String"]["input"]>;
  multipliers?: InputMaybe<Scalars["String"]["input"]>;
  points_breakdown?: InputMaybe<Scalars["String"]["input"]>;
  titles?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for incrementing numeric columns in table "user_metrics" */
export type UserMetricsIncInput = {
  best_streak?: InputMaybe<Scalars["Int"]["input"]>;
  current_level?: InputMaybe<Scalars["Int"]["input"]>;
  current_streak?: InputMaybe<Scalars["Int"]["input"]>;
  current_xp?: InputMaybe<Scalars["Int"]["input"]>;
  downvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  points?: InputMaybe<Scalars["Int"]["input"]>;
  today_vote_count?: InputMaybe<Scalars["Int"]["input"]>;
  total_reading_time?: InputMaybe<Scalars["Int"]["input"]>;
  total_votes?: InputMaybe<Scalars["Int"]["input"]>;
  upvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  vote_accuracy?: InputMaybe<Scalars["numeric"]["input"]>;
  xp_to_next_level?: InputMaybe<Scalars["Int"]["input"]>;
};

/** input type for inserting data into table "user_metrics" */
export type UserMetricsInsertInput = {
  achievements?: InputMaybe<Scalars["jsonb"]["input"]>;
  best_streak?: InputMaybe<Scalars["Int"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  current_level?: InputMaybe<Scalars["Int"]["input"]>;
  current_streak?: InputMaybe<Scalars["Int"]["input"]>;
  current_xp?: InputMaybe<Scalars["Int"]["input"]>;
  downvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  interaction_stats?: InputMaybe<Scalars["jsonb"]["input"]>;
  last_vote_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  multipliers?: InputMaybe<Scalars["jsonb"]["input"]>;
  points?: InputMaybe<Scalars["Int"]["input"]>;
  points_breakdown?: InputMaybe<Scalars["jsonb"]["input"]>;
  titles?: InputMaybe<Scalars["jsonb"]["input"]>;
  today_vote_count?: InputMaybe<Scalars["Int"]["input"]>;
  total_reading_time?: InputMaybe<Scalars["Int"]["input"]>;
  total_votes?: InputMaybe<Scalars["Int"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  upvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
  vote_accuracy?: InputMaybe<Scalars["numeric"]["input"]>;
  xp_to_next_level?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate max on columns */
export type UserMetricsMaxFields = {
  __typename?: "user_metrics_max_fields";
  best_streak?: Maybe<Scalars["Int"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  current_level?: Maybe<Scalars["Int"]["output"]>;
  current_streak?: Maybe<Scalars["Int"]["output"]>;
  current_xp?: Maybe<Scalars["Int"]["output"]>;
  downvote_count?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  last_vote_date?: Maybe<Scalars["timestamptz"]["output"]>;
  points?: Maybe<Scalars["Int"]["output"]>;
  today_vote_count?: Maybe<Scalars["Int"]["output"]>;
  total_reading_time?: Maybe<Scalars["Int"]["output"]>;
  total_votes?: Maybe<Scalars["Int"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  upvote_count?: Maybe<Scalars["Int"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
  vote_accuracy?: Maybe<Scalars["numeric"]["output"]>;
  xp_to_next_level?: Maybe<Scalars["Int"]["output"]>;
};

/** aggregate min on columns */
export type UserMetricsMinFields = {
  __typename?: "user_metrics_min_fields";
  best_streak?: Maybe<Scalars["Int"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  current_level?: Maybe<Scalars["Int"]["output"]>;
  current_streak?: Maybe<Scalars["Int"]["output"]>;
  current_xp?: Maybe<Scalars["Int"]["output"]>;
  downvote_count?: Maybe<Scalars["Int"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  last_vote_date?: Maybe<Scalars["timestamptz"]["output"]>;
  points?: Maybe<Scalars["Int"]["output"]>;
  today_vote_count?: Maybe<Scalars["Int"]["output"]>;
  total_reading_time?: Maybe<Scalars["Int"]["output"]>;
  total_votes?: Maybe<Scalars["Int"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  upvote_count?: Maybe<Scalars["Int"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
  vote_accuracy?: Maybe<Scalars["numeric"]["output"]>;
  xp_to_next_level?: Maybe<Scalars["Int"]["output"]>;
};

/** response of any mutation on the table "user_metrics" */
export type UserMetricsMutationResponse = {
  __typename?: "user_metrics_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<UserMetrics>;
};

/** input type for inserting object relation for remote table "user_metrics" */
export type UserMetricsObjRelInsertInput = {
  data: UserMetricsInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<UserMetricsOnConflict>;
};

/** on_conflict condition type for table "user_metrics" */
export type UserMetricsOnConflict = {
  constraint: UserMetricsConstraint;
  update_columns?: Array<UserMetricsUpdateColumn>;
  where?: InputMaybe<UserMetricsBoolExp>;
};

/** Ordering options when selecting data from "user_metrics". */
export type UserMetricsOrderBy = {
  achievements?: InputMaybe<OrderBy>;
  best_streak?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  current_level?: InputMaybe<OrderBy>;
  current_streak?: InputMaybe<OrderBy>;
  current_xp?: InputMaybe<OrderBy>;
  downvote_count?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  interaction_stats?: InputMaybe<OrderBy>;
  last_vote_date?: InputMaybe<OrderBy>;
  multipliers?: InputMaybe<OrderBy>;
  points?: InputMaybe<OrderBy>;
  points_breakdown?: InputMaybe<OrderBy>;
  titles?: InputMaybe<OrderBy>;
  today_vote_count?: InputMaybe<OrderBy>;
  total_reading_time?: InputMaybe<OrderBy>;
  total_votes?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  upvote_count?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  user_profile?: InputMaybe<UserProfilesOrderBy>;
  vote_accuracy?: InputMaybe<OrderBy>;
  xp_to_next_level?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: user_metrics */
export type UserMetricsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type UserMetricsPrependInput = {
  achievements?: InputMaybe<Scalars["jsonb"]["input"]>;
  interaction_stats?: InputMaybe<Scalars["jsonb"]["input"]>;
  multipliers?: InputMaybe<Scalars["jsonb"]["input"]>;
  points_breakdown?: InputMaybe<Scalars["jsonb"]["input"]>;
  titles?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "user_metrics" */
export enum UserMetricsSelectColumn {
  /** column name */
  ACHIEVEMENTS = "achievements",
  /** column name */
  BEST_STREAK = "best_streak",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  CURRENT_LEVEL = "current_level",
  /** column name */
  CURRENT_STREAK = "current_streak",
  /** column name */
  CURRENT_XP = "current_xp",
  /** column name */
  DOWNVOTE_COUNT = "downvote_count",
  /** column name */
  ID = "id",
  /** column name */
  INTERACTION_STATS = "interaction_stats",
  /** column name */
  LAST_VOTE_DATE = "last_vote_date",
  /** column name */
  MULTIPLIERS = "multipliers",
  /** column name */
  POINTS = "points",
  /** column name */
  POINTS_BREAKDOWN = "points_breakdown",
  /** column name */
  TITLES = "titles",
  /** column name */
  TODAY_VOTE_COUNT = "today_vote_count",
  /** column name */
  TOTAL_READING_TIME = "total_reading_time",
  /** column name */
  TOTAL_VOTES = "total_votes",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  UPVOTE_COUNT = "upvote_count",
  /** column name */
  USER_ID = "user_id",
  /** column name */
  VOTE_ACCURACY = "vote_accuracy",
  /** column name */
  XP_TO_NEXT_LEVEL = "xp_to_next_level",
}

/** input type for updating data in table "user_metrics" */
export type UserMetricsSetInput = {
  achievements?: InputMaybe<Scalars["jsonb"]["input"]>;
  best_streak?: InputMaybe<Scalars["Int"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  current_level?: InputMaybe<Scalars["Int"]["input"]>;
  current_streak?: InputMaybe<Scalars["Int"]["input"]>;
  current_xp?: InputMaybe<Scalars["Int"]["input"]>;
  downvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  interaction_stats?: InputMaybe<Scalars["jsonb"]["input"]>;
  last_vote_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  multipliers?: InputMaybe<Scalars["jsonb"]["input"]>;
  points?: InputMaybe<Scalars["Int"]["input"]>;
  points_breakdown?: InputMaybe<Scalars["jsonb"]["input"]>;
  titles?: InputMaybe<Scalars["jsonb"]["input"]>;
  today_vote_count?: InputMaybe<Scalars["Int"]["input"]>;
  total_reading_time?: InputMaybe<Scalars["Int"]["input"]>;
  total_votes?: InputMaybe<Scalars["Int"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  upvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  vote_accuracy?: InputMaybe<Scalars["numeric"]["input"]>;
  xp_to_next_level?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate stddev on columns */
export type UserMetricsStddevFields = {
  __typename?: "user_metrics_stddev_fields";
  best_streak?: Maybe<Scalars["Float"]["output"]>;
  current_level?: Maybe<Scalars["Float"]["output"]>;
  current_streak?: Maybe<Scalars["Float"]["output"]>;
  current_xp?: Maybe<Scalars["Float"]["output"]>;
  downvote_count?: Maybe<Scalars["Float"]["output"]>;
  points?: Maybe<Scalars["Float"]["output"]>;
  today_vote_count?: Maybe<Scalars["Float"]["output"]>;
  total_reading_time?: Maybe<Scalars["Float"]["output"]>;
  total_votes?: Maybe<Scalars["Float"]["output"]>;
  upvote_count?: Maybe<Scalars["Float"]["output"]>;
  vote_accuracy?: Maybe<Scalars["Float"]["output"]>;
  xp_to_next_level?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type UserMetricsStddevPopFields = {
  __typename?: "user_metrics_stddev_pop_fields";
  best_streak?: Maybe<Scalars["Float"]["output"]>;
  current_level?: Maybe<Scalars["Float"]["output"]>;
  current_streak?: Maybe<Scalars["Float"]["output"]>;
  current_xp?: Maybe<Scalars["Float"]["output"]>;
  downvote_count?: Maybe<Scalars["Float"]["output"]>;
  points?: Maybe<Scalars["Float"]["output"]>;
  today_vote_count?: Maybe<Scalars["Float"]["output"]>;
  total_reading_time?: Maybe<Scalars["Float"]["output"]>;
  total_votes?: Maybe<Scalars["Float"]["output"]>;
  upvote_count?: Maybe<Scalars["Float"]["output"]>;
  vote_accuracy?: Maybe<Scalars["Float"]["output"]>;
  xp_to_next_level?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type UserMetricsStddevSampFields = {
  __typename?: "user_metrics_stddev_samp_fields";
  best_streak?: Maybe<Scalars["Float"]["output"]>;
  current_level?: Maybe<Scalars["Float"]["output"]>;
  current_streak?: Maybe<Scalars["Float"]["output"]>;
  current_xp?: Maybe<Scalars["Float"]["output"]>;
  downvote_count?: Maybe<Scalars["Float"]["output"]>;
  points?: Maybe<Scalars["Float"]["output"]>;
  today_vote_count?: Maybe<Scalars["Float"]["output"]>;
  total_reading_time?: Maybe<Scalars["Float"]["output"]>;
  total_votes?: Maybe<Scalars["Float"]["output"]>;
  upvote_count?: Maybe<Scalars["Float"]["output"]>;
  vote_accuracy?: Maybe<Scalars["Float"]["output"]>;
  xp_to_next_level?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "user_metrics" */
export type UserMetricsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: UserMetricsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type UserMetricsStreamCursorValueInput = {
  achievements?: InputMaybe<Scalars["jsonb"]["input"]>;
  best_streak?: InputMaybe<Scalars["Int"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  current_level?: InputMaybe<Scalars["Int"]["input"]>;
  current_streak?: InputMaybe<Scalars["Int"]["input"]>;
  current_xp?: InputMaybe<Scalars["Int"]["input"]>;
  downvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  interaction_stats?: InputMaybe<Scalars["jsonb"]["input"]>;
  last_vote_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  multipliers?: InputMaybe<Scalars["jsonb"]["input"]>;
  points?: InputMaybe<Scalars["Int"]["input"]>;
  points_breakdown?: InputMaybe<Scalars["jsonb"]["input"]>;
  titles?: InputMaybe<Scalars["jsonb"]["input"]>;
  today_vote_count?: InputMaybe<Scalars["Int"]["input"]>;
  total_reading_time?: InputMaybe<Scalars["Int"]["input"]>;
  total_votes?: InputMaybe<Scalars["Int"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  upvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  vote_accuracy?: InputMaybe<Scalars["numeric"]["input"]>;
  xp_to_next_level?: InputMaybe<Scalars["Int"]["input"]>;
};

/** aggregate sum on columns */
export type UserMetricsSumFields = {
  __typename?: "user_metrics_sum_fields";
  best_streak?: Maybe<Scalars["Int"]["output"]>;
  current_level?: Maybe<Scalars["Int"]["output"]>;
  current_streak?: Maybe<Scalars["Int"]["output"]>;
  current_xp?: Maybe<Scalars["Int"]["output"]>;
  downvote_count?: Maybe<Scalars["Int"]["output"]>;
  points?: Maybe<Scalars["Int"]["output"]>;
  today_vote_count?: Maybe<Scalars["Int"]["output"]>;
  total_reading_time?: Maybe<Scalars["Int"]["output"]>;
  total_votes?: Maybe<Scalars["Int"]["output"]>;
  upvote_count?: Maybe<Scalars["Int"]["output"]>;
  vote_accuracy?: Maybe<Scalars["numeric"]["output"]>;
  xp_to_next_level?: Maybe<Scalars["Int"]["output"]>;
};

/** update columns of table "user_metrics" */
export enum UserMetricsUpdateColumn {
  /** column name */
  ACHIEVEMENTS = "achievements",
  /** column name */
  BEST_STREAK = "best_streak",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  CURRENT_LEVEL = "current_level",
  /** column name */
  CURRENT_STREAK = "current_streak",
  /** column name */
  CURRENT_XP = "current_xp",
  /** column name */
  DOWNVOTE_COUNT = "downvote_count",
  /** column name */
  ID = "id",
  /** column name */
  INTERACTION_STATS = "interaction_stats",
  /** column name */
  LAST_VOTE_DATE = "last_vote_date",
  /** column name */
  MULTIPLIERS = "multipliers",
  /** column name */
  POINTS = "points",
  /** column name */
  POINTS_BREAKDOWN = "points_breakdown",
  /** column name */
  TITLES = "titles",
  /** column name */
  TODAY_VOTE_COUNT = "today_vote_count",
  /** column name */
  TOTAL_READING_TIME = "total_reading_time",
  /** column name */
  TOTAL_VOTES = "total_votes",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  UPVOTE_COUNT = "upvote_count",
  /** column name */
  USER_ID = "user_id",
  /** column name */
  VOTE_ACCURACY = "vote_accuracy",
  /** column name */
  XP_TO_NEXT_LEVEL = "xp_to_next_level",
}

export type UserMetricsUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<UserMetricsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<UserMetricsDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<UserMetricsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<UserMetricsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<UserMetricsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<UserMetricsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<UserMetricsSetInput>;
  /** filter the rows which have to be updated */
  where: UserMetricsBoolExp;
};

/** aggregate var_pop on columns */
export type UserMetricsVarPopFields = {
  __typename?: "user_metrics_var_pop_fields";
  best_streak?: Maybe<Scalars["Float"]["output"]>;
  current_level?: Maybe<Scalars["Float"]["output"]>;
  current_streak?: Maybe<Scalars["Float"]["output"]>;
  current_xp?: Maybe<Scalars["Float"]["output"]>;
  downvote_count?: Maybe<Scalars["Float"]["output"]>;
  points?: Maybe<Scalars["Float"]["output"]>;
  today_vote_count?: Maybe<Scalars["Float"]["output"]>;
  total_reading_time?: Maybe<Scalars["Float"]["output"]>;
  total_votes?: Maybe<Scalars["Float"]["output"]>;
  upvote_count?: Maybe<Scalars["Float"]["output"]>;
  vote_accuracy?: Maybe<Scalars["Float"]["output"]>;
  xp_to_next_level?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type UserMetricsVarSampFields = {
  __typename?: "user_metrics_var_samp_fields";
  best_streak?: Maybe<Scalars["Float"]["output"]>;
  current_level?: Maybe<Scalars["Float"]["output"]>;
  current_streak?: Maybe<Scalars["Float"]["output"]>;
  current_xp?: Maybe<Scalars["Float"]["output"]>;
  downvote_count?: Maybe<Scalars["Float"]["output"]>;
  points?: Maybe<Scalars["Float"]["output"]>;
  today_vote_count?: Maybe<Scalars["Float"]["output"]>;
  total_reading_time?: Maybe<Scalars["Float"]["output"]>;
  total_votes?: Maybe<Scalars["Float"]["output"]>;
  upvote_count?: Maybe<Scalars["Float"]["output"]>;
  vote_accuracy?: Maybe<Scalars["Float"]["output"]>;
  xp_to_next_level?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type UserMetricsVarianceFields = {
  __typename?: "user_metrics_variance_fields";
  best_streak?: Maybe<Scalars["Float"]["output"]>;
  current_level?: Maybe<Scalars["Float"]["output"]>;
  current_streak?: Maybe<Scalars["Float"]["output"]>;
  current_xp?: Maybe<Scalars["Float"]["output"]>;
  downvote_count?: Maybe<Scalars["Float"]["output"]>;
  points?: Maybe<Scalars["Float"]["output"]>;
  today_vote_count?: Maybe<Scalars["Float"]["output"]>;
  total_reading_time?: Maybe<Scalars["Float"]["output"]>;
  total_votes?: Maybe<Scalars["Float"]["output"]>;
  upvote_count?: Maybe<Scalars["Float"]["output"]>;
  vote_accuracy?: Maybe<Scalars["Float"]["output"]>;
  xp_to_next_level?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "user_profiles" */
export type UserProfiles = {
  __typename?: "user_profiles";
  /** An array relationship */
  addresses: Array<Addresses>;
  /** An aggregate relationship */
  addresses_aggregate: AddressesAggregate;
  avatar?: Maybe<Scalars["String"]["output"]>;
  /** An array relationship */
  comments: Array<Comments>;
  /** An aggregate relationship */
  comments_aggregate: CommentsAggregate;
  /** An array relationship */
  company_employees: Array<CompanyEmployees>;
  /** An aggregate relationship */
  company_employees_aggregate: CompanyEmployeesAggregate;
  /** An array relationship */
  contacts: Array<Contacts>;
  /** An aggregate relationship */
  contacts_aggregate: ContactsAggregate;
  /** An array relationship */
  content_source_visits: Array<ContentSourceVisits>;
  /** An aggregate relationship */
  content_source_visits_aggregate: ContentSourceVisitsAggregate;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  /** An array relationship */
  customer_payments: Array<CustomerPayments>;
  /** An aggregate relationship */
  customer_payments_aggregate: CustomerPaymentsAggregate;
  /** An array relationship */
  customer_subscriptions: Array<CustomerSubscriptions>;
  /** An aggregate relationship */
  customer_subscriptions_aggregate: CustomerSubscriptionsAggregate;
  dob?: Maybe<Scalars["date"]["output"]>;
  email: Scalars["String"]["output"];
  /** An array relationship */
  feedbacks: Array<Feedbacks>;
  /** An aggregate relationship */
  feedbacks_aggregate: FeedbacksAggregate;
  /** An array relationship */
  feeds: Array<Feeds>;
  /** An aggregate relationship */
  feeds_aggregate: FeedsAggregate;
  followed_count?: Maybe<Scalars["Int"]["output"]>;
  followers_count?: Maybe<Scalars["Int"]["output"]>;
  /** An array relationship */
  follows: Array<Follows>;
  /** An aggregate relationship */
  follows_aggregate: FollowsAggregate;
  gender_id?: Maybe<Scalars["smallint"]["output"]>;
  given_name?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["uuid"]["output"];
  introduction?: Maybe<Scalars["String"]["output"]>;
  is_active?: Maybe<Scalars["Boolean"]["output"]>;
  last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  plan?: Maybe<Scalars["app_plan_enum"]["output"]>;
  role: Scalars["app_role_enum"]["output"];
  surname?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  /** An object relationship */
  user_metric?: Maybe<UserMetrics>;
  username?: Maybe<Scalars["String"]["output"]>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesAddressesArgs = {
  distinct_on?: InputMaybe<Array<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesAddressesAggregateArgs = {
  distinct_on?: InputMaybe<Array<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesCommentsArgs = {
  distinct_on?: InputMaybe<Array<CommentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CommentsOrderBy>>;
  where?: InputMaybe<CommentsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesCommentsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CommentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CommentsOrderBy>>;
  where?: InputMaybe<CommentsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesCompanyEmployeesArgs = {
  distinct_on?: InputMaybe<Array<CompanyEmployeesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyEmployeesOrderBy>>;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesCompanyEmployeesAggregateArgs = {
  distinct_on?: InputMaybe<Array<CompanyEmployeesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyEmployeesOrderBy>>;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesContactsArgs = {
  distinct_on?: InputMaybe<Array<ContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContactsOrderBy>>;
  where?: InputMaybe<ContactsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesContactsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContactsOrderBy>>;
  where?: InputMaybe<ContactsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesContentSourceVisitsArgs = {
  distinct_on?: InputMaybe<Array<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesContentSourceVisitsAggregateArgs = {
  distinct_on?: InputMaybe<Array<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesCustomerPaymentsArgs = {
  distinct_on?: InputMaybe<Array<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesCustomerPaymentsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesCustomerSubscriptionsArgs = {
  distinct_on?: InputMaybe<Array<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesCustomerSubscriptionsAggregateArgs = {
  distinct_on?: InputMaybe<Array<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesFeedbacksArgs = {
  distinct_on?: InputMaybe<Array<FeedbacksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedbacksOrderBy>>;
  where?: InputMaybe<FeedbacksBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesFeedbacksAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeedbacksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedbacksOrderBy>>;
  where?: InputMaybe<FeedbacksBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesFeedsArgs = {
  distinct_on?: InputMaybe<Array<FeedsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedsOrderBy>>;
  where?: InputMaybe<FeedsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesFeedsAggregateArgs = {
  distinct_on?: InputMaybe<Array<FeedsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedsOrderBy>>;
  where?: InputMaybe<FeedsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesFollowsArgs = {
  distinct_on?: InputMaybe<Array<FollowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FollowsOrderBy>>;
  where?: InputMaybe<FollowsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesFollowsAggregateArgs = {
  distinct_on?: InputMaybe<Array<FollowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FollowsOrderBy>>;
  where?: InputMaybe<FollowsBoolExp>;
};

/** aggregated selection of "user_profiles" */
export type UserProfilesAggregate = {
  __typename?: "user_profiles_aggregate";
  aggregate?: Maybe<UserProfilesAggregateFields>;
  nodes: Array<UserProfiles>;
};

/** aggregate fields of "user_profiles" */
export type UserProfilesAggregateFields = {
  __typename?: "user_profiles_aggregate_fields";
  avg?: Maybe<UserProfilesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<UserProfilesMaxFields>;
  min?: Maybe<UserProfilesMinFields>;
  stddev?: Maybe<UserProfilesStddevFields>;
  stddev_pop?: Maybe<UserProfilesStddevPopFields>;
  stddev_samp?: Maybe<UserProfilesStddevSampFields>;
  sum?: Maybe<UserProfilesSumFields>;
  var_pop?: Maybe<UserProfilesVarPopFields>;
  var_samp?: Maybe<UserProfilesVarSampFields>;
  variance?: Maybe<UserProfilesVarianceFields>;
};

/** aggregate fields of "user_profiles" */
export type UserProfilesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<UserProfilesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type UserProfilesAvgFields = {
  __typename?: "user_profiles_avg_fields";
  followed_count?: Maybe<Scalars["Float"]["output"]>;
  followers_count?: Maybe<Scalars["Float"]["output"]>;
  gender_id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "user_profiles". All fields are combined with a logical 'AND'. */
export type UserProfilesBoolExp = {
  _and?: InputMaybe<Array<UserProfilesBoolExp>>;
  _not?: InputMaybe<UserProfilesBoolExp>;
  _or?: InputMaybe<Array<UserProfilesBoolExp>>;
  addresses?: InputMaybe<AddressesBoolExp>;
  addresses_aggregate?: InputMaybe<AddressesAggregateBoolExp>;
  avatar?: InputMaybe<StringComparisonExp>;
  comments?: InputMaybe<CommentsBoolExp>;
  comments_aggregate?: InputMaybe<CommentsAggregateBoolExp>;
  company_employees?: InputMaybe<CompanyEmployeesBoolExp>;
  company_employees_aggregate?: InputMaybe<CompanyEmployeesAggregateBoolExp>;
  contacts?: InputMaybe<ContactsBoolExp>;
  contacts_aggregate?: InputMaybe<ContactsAggregateBoolExp>;
  content_source_visits?: InputMaybe<ContentSourceVisitsBoolExp>;
  content_source_visits_aggregate?: InputMaybe<ContentSourceVisitsAggregateBoolExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  customer_payments?: InputMaybe<CustomerPaymentsBoolExp>;
  customer_payments_aggregate?: InputMaybe<CustomerPaymentsAggregateBoolExp>;
  customer_subscriptions?: InputMaybe<CustomerSubscriptionsBoolExp>;
  customer_subscriptions_aggregate?: InputMaybe<CustomerSubscriptionsAggregateBoolExp>;
  dob?: InputMaybe<DateComparisonExp>;
  email?: InputMaybe<StringComparisonExp>;
  feedbacks?: InputMaybe<FeedbacksBoolExp>;
  feedbacks_aggregate?: InputMaybe<FeedbacksAggregateBoolExp>;
  feeds?: InputMaybe<FeedsBoolExp>;
  feeds_aggregate?: InputMaybe<FeedsAggregateBoolExp>;
  followed_count?: InputMaybe<IntComparisonExp>;
  followers_count?: InputMaybe<IntComparisonExp>;
  follows?: InputMaybe<FollowsBoolExp>;
  follows_aggregate?: InputMaybe<FollowsAggregateBoolExp>;
  gender_id?: InputMaybe<SmallintComparisonExp>;
  given_name?: InputMaybe<StringComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  introduction?: InputMaybe<StringComparisonExp>;
  is_active?: InputMaybe<BooleanComparisonExp>;
  last_seen?: InputMaybe<TimestamptzComparisonExp>;
  plan?: InputMaybe<AppPlanEnumComparisonExp>;
  role?: InputMaybe<AppRoleEnumComparisonExp>;
  surname?: InputMaybe<StringComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
  user_metric?: InputMaybe<UserMetricsBoolExp>;
  username?: InputMaybe<StringComparisonExp>;
};

/** unique or primary key constraints on table "user_profiles" */
export enum UserProfilesConstraint {
  /** unique or primary key constraint on columns "id" */
  USER_PROFILES_PKEY = "user_profiles_pkey",
  /** unique or primary key constraint on columns "id" */
  USERS_AUTH_ID_KEY = "users_auth_id_key",
  /** unique or primary key constraint on columns "email" */
  USERS_EMAIL_KEY = "users_email_key",
}

/** input type for incrementing numeric columns in table "user_profiles" */
export type UserProfilesIncInput = {
  followed_count?: InputMaybe<Scalars["Int"]["input"]>;
  followers_count?: InputMaybe<Scalars["Int"]["input"]>;
  gender_id?: InputMaybe<Scalars["smallint"]["input"]>;
};

/** input type for inserting data into table "user_profiles" */
export type UserProfilesInsertInput = {
  addresses?: InputMaybe<AddressesArrRelInsertInput>;
  avatar?: InputMaybe<Scalars["String"]["input"]>;
  comments?: InputMaybe<CommentsArrRelInsertInput>;
  company_employees?: InputMaybe<CompanyEmployeesArrRelInsertInput>;
  contacts?: InputMaybe<ContactsArrRelInsertInput>;
  content_source_visits?: InputMaybe<ContentSourceVisitsArrRelInsertInput>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  customer_payments?: InputMaybe<CustomerPaymentsArrRelInsertInput>;
  customer_subscriptions?: InputMaybe<CustomerSubscriptionsArrRelInsertInput>;
  dob?: InputMaybe<Scalars["date"]["input"]>;
  email?: InputMaybe<Scalars["String"]["input"]>;
  feedbacks?: InputMaybe<FeedbacksArrRelInsertInput>;
  feeds?: InputMaybe<FeedsArrRelInsertInput>;
  followed_count?: InputMaybe<Scalars["Int"]["input"]>;
  followers_count?: InputMaybe<Scalars["Int"]["input"]>;
  follows?: InputMaybe<FollowsArrRelInsertInput>;
  gender_id?: InputMaybe<Scalars["smallint"]["input"]>;
  given_name?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  introduction?: InputMaybe<Scalars["String"]["input"]>;
  is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  last_seen?: InputMaybe<Scalars["timestamptz"]["input"]>;
  plan?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
  role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  surname?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  user_metric?: InputMaybe<UserMetricsObjRelInsertInput>;
  username?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate max on columns */
export type UserProfilesMaxFields = {
  __typename?: "user_profiles_max_fields";
  avatar?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  dob?: Maybe<Scalars["date"]["output"]>;
  email?: Maybe<Scalars["String"]["output"]>;
  followed_count?: Maybe<Scalars["Int"]["output"]>;
  followers_count?: Maybe<Scalars["Int"]["output"]>;
  gender_id?: Maybe<Scalars["smallint"]["output"]>;
  given_name?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  introduction?: Maybe<Scalars["String"]["output"]>;
  last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  plan?: Maybe<Scalars["app_plan_enum"]["output"]>;
  role?: Maybe<Scalars["app_role_enum"]["output"]>;
  surname?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  username?: Maybe<Scalars["String"]["output"]>;
};

/** aggregate min on columns */
export type UserProfilesMinFields = {
  __typename?: "user_profiles_min_fields";
  avatar?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  dob?: Maybe<Scalars["date"]["output"]>;
  email?: Maybe<Scalars["String"]["output"]>;
  followed_count?: Maybe<Scalars["Int"]["output"]>;
  followers_count?: Maybe<Scalars["Int"]["output"]>;
  gender_id?: Maybe<Scalars["smallint"]["output"]>;
  given_name?: Maybe<Scalars["String"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  introduction?: Maybe<Scalars["String"]["output"]>;
  last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  plan?: Maybe<Scalars["app_plan_enum"]["output"]>;
  role?: Maybe<Scalars["app_role_enum"]["output"]>;
  surname?: Maybe<Scalars["String"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  username?: Maybe<Scalars["String"]["output"]>;
};

/** response of any mutation on the table "user_profiles" */
export type UserProfilesMutationResponse = {
  __typename?: "user_profiles_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<UserProfiles>;
};

/** input type for inserting object relation for remote table "user_profiles" */
export type UserProfilesObjRelInsertInput = {
  data: UserProfilesInsertInput;
  /** upsert condition */
  on_conflict?: InputMaybe<UserProfilesOnConflict>;
};

/** on_conflict condition type for table "user_profiles" */
export type UserProfilesOnConflict = {
  constraint: UserProfilesConstraint;
  update_columns?: Array<UserProfilesUpdateColumn>;
  where?: InputMaybe<UserProfilesBoolExp>;
};

/** Ordering options when selecting data from "user_profiles". */
export type UserProfilesOrderBy = {
  addresses_aggregate?: InputMaybe<AddressesAggregateOrderBy>;
  avatar?: InputMaybe<OrderBy>;
  comments_aggregate?: InputMaybe<CommentsAggregateOrderBy>;
  company_employees_aggregate?: InputMaybe<CompanyEmployeesAggregateOrderBy>;
  contacts_aggregate?: InputMaybe<ContactsAggregateOrderBy>;
  content_source_visits_aggregate?: InputMaybe<ContentSourceVisitsAggregateOrderBy>;
  created_at?: InputMaybe<OrderBy>;
  customer_payments_aggregate?: InputMaybe<CustomerPaymentsAggregateOrderBy>;
  customer_subscriptions_aggregate?: InputMaybe<CustomerSubscriptionsAggregateOrderBy>;
  dob?: InputMaybe<OrderBy>;
  email?: InputMaybe<OrderBy>;
  feedbacks_aggregate?: InputMaybe<FeedbacksAggregateOrderBy>;
  feeds_aggregate?: InputMaybe<FeedsAggregateOrderBy>;
  followed_count?: InputMaybe<OrderBy>;
  followers_count?: InputMaybe<OrderBy>;
  follows_aggregate?: InputMaybe<FollowsAggregateOrderBy>;
  gender_id?: InputMaybe<OrderBy>;
  given_name?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  introduction?: InputMaybe<OrderBy>;
  is_active?: InputMaybe<OrderBy>;
  last_seen?: InputMaybe<OrderBy>;
  plan?: InputMaybe<OrderBy>;
  role?: InputMaybe<OrderBy>;
  surname?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
  user_metric?: InputMaybe<UserMetricsOrderBy>;
  username?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: user_profiles */
export type UserProfilesPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "user_profiles" */
export enum UserProfilesSelectColumn {
  /** column name */
  AVATAR = "avatar",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DOB = "dob",
  /** column name */
  EMAIL = "email",
  /** column name */
  FOLLOWED_COUNT = "followed_count",
  /** column name */
  FOLLOWERS_COUNT = "followers_count",
  /** column name */
  GENDER_ID = "gender_id",
  /** column name */
  GIVEN_NAME = "given_name",
  /** column name */
  ID = "id",
  /** column name */
  INTRODUCTION = "introduction",
  /** column name */
  IS_ACTIVE = "is_active",
  /** column name */
  LAST_SEEN = "last_seen",
  /** column name */
  PLAN = "plan",
  /** column name */
  ROLE = "role",
  /** column name */
  SURNAME = "surname",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USERNAME = "username",
}

/** input type for updating data in table "user_profiles" */
export type UserProfilesSetInput = {
  avatar?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  dob?: InputMaybe<Scalars["date"]["input"]>;
  email?: InputMaybe<Scalars["String"]["input"]>;
  followed_count?: InputMaybe<Scalars["Int"]["input"]>;
  followers_count?: InputMaybe<Scalars["Int"]["input"]>;
  gender_id?: InputMaybe<Scalars["smallint"]["input"]>;
  given_name?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  introduction?: InputMaybe<Scalars["String"]["input"]>;
  is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  last_seen?: InputMaybe<Scalars["timestamptz"]["input"]>;
  plan?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
  role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  surname?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  username?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate stddev on columns */
export type UserProfilesStddevFields = {
  __typename?: "user_profiles_stddev_fields";
  followed_count?: Maybe<Scalars["Float"]["output"]>;
  followers_count?: Maybe<Scalars["Float"]["output"]>;
  gender_id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type UserProfilesStddevPopFields = {
  __typename?: "user_profiles_stddev_pop_fields";
  followed_count?: Maybe<Scalars["Float"]["output"]>;
  followers_count?: Maybe<Scalars["Float"]["output"]>;
  gender_id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type UserProfilesStddevSampFields = {
  __typename?: "user_profiles_stddev_samp_fields";
  followed_count?: Maybe<Scalars["Float"]["output"]>;
  followers_count?: Maybe<Scalars["Float"]["output"]>;
  gender_id?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "user_profiles" */
export type UserProfilesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: UserProfilesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type UserProfilesStreamCursorValueInput = {
  avatar?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  dob?: InputMaybe<Scalars["date"]["input"]>;
  email?: InputMaybe<Scalars["String"]["input"]>;
  followed_count?: InputMaybe<Scalars["Int"]["input"]>;
  followers_count?: InputMaybe<Scalars["Int"]["input"]>;
  gender_id?: InputMaybe<Scalars["smallint"]["input"]>;
  given_name?: InputMaybe<Scalars["String"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  introduction?: InputMaybe<Scalars["String"]["input"]>;
  is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  last_seen?: InputMaybe<Scalars["timestamptz"]["input"]>;
  plan?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
  role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  surname?: InputMaybe<Scalars["String"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  username?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregate sum on columns */
export type UserProfilesSumFields = {
  __typename?: "user_profiles_sum_fields";
  followed_count?: Maybe<Scalars["Int"]["output"]>;
  followers_count?: Maybe<Scalars["Int"]["output"]>;
  gender_id?: Maybe<Scalars["smallint"]["output"]>;
};

/** update columns of table "user_profiles" */
export enum UserProfilesUpdateColumn {
  /** column name */
  AVATAR = "avatar",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  DOB = "dob",
  /** column name */
  EMAIL = "email",
  /** column name */
  FOLLOWED_COUNT = "followed_count",
  /** column name */
  FOLLOWERS_COUNT = "followers_count",
  /** column name */
  GENDER_ID = "gender_id",
  /** column name */
  GIVEN_NAME = "given_name",
  /** column name */
  ID = "id",
  /** column name */
  INTRODUCTION = "introduction",
  /** column name */
  IS_ACTIVE = "is_active",
  /** column name */
  LAST_SEEN = "last_seen",
  /** column name */
  PLAN = "plan",
  /** column name */
  ROLE = "role",
  /** column name */
  SURNAME = "surname",
  /** column name */
  UPDATED_AT = "updated_at",
  /** column name */
  USERNAME = "username",
}

export type UserProfilesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<UserProfilesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<UserProfilesSetInput>;
  /** filter the rows which have to be updated */
  where: UserProfilesBoolExp;
};

/** aggregate var_pop on columns */
export type UserProfilesVarPopFields = {
  __typename?: "user_profiles_var_pop_fields";
  followed_count?: Maybe<Scalars["Float"]["output"]>;
  followers_count?: Maybe<Scalars["Float"]["output"]>;
  gender_id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type UserProfilesVarSampFields = {
  __typename?: "user_profiles_var_samp_fields";
  followed_count?: Maybe<Scalars["Float"]["output"]>;
  followers_count?: Maybe<Scalars["Float"]["output"]>;
  gender_id?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type UserProfilesVarianceFields = {
  __typename?: "user_profiles_variance_fields";
  followed_count?: Maybe<Scalars["Float"]["output"]>;
  followers_count?: Maybe<Scalars["Float"]["output"]>;
  gender_id?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to compare columns of type "uuid". All fields are combined with logical 'AND'. */
export type UuidArrayComparisonExp = {
  /** is the array contained in the given array value */
  _contained_in?: InputMaybe<Array<Scalars["uuid"]["input"]>>;
  /** does the array contain the given value */
  _contains?: InputMaybe<Array<Scalars["uuid"]["input"]>>;
  _eq?: InputMaybe<Array<Scalars["uuid"]["input"]>>;
  _gt?: InputMaybe<Array<Scalars["uuid"]["input"]>>;
  _gte?: InputMaybe<Array<Scalars["uuid"]["input"]>>;
  _in?: InputMaybe<Array<Array<Scalars["uuid"]["input"]>>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Array<Scalars["uuid"]["input"]>>;
  _lte?: InputMaybe<Array<Scalars["uuid"]["input"]>>;
  _neq?: InputMaybe<Array<Scalars["uuid"]["input"]>>;
  _nin?: InputMaybe<Array<Array<Scalars["uuid"]["input"]>>>;
};

/** Boolean expression to compare columns of type "uuid". All fields are combined with logical 'AND'. */
export type UuidComparisonExp = {
  _eq?: InputMaybe<Scalars["uuid"]["input"]>;
  _gt?: InputMaybe<Scalars["uuid"]["input"]>;
  _gte?: InputMaybe<Scalars["uuid"]["input"]>;
  _in?: InputMaybe<Array<Scalars["uuid"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["uuid"]["input"]>;
  _lte?: InputMaybe<Scalars["uuid"]["input"]>;
  _neq?: InputMaybe<Scalars["uuid"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["uuid"]["input"]>>;
};

/** Boolean expression to compare columns of type "vector". All fields are combined with logical 'AND'. */
export type VectorComparisonExp = {
  _eq?: InputMaybe<Scalars["vector"]["input"]>;
  _gt?: InputMaybe<Scalars["vector"]["input"]>;
  _gte?: InputMaybe<Scalars["vector"]["input"]>;
  _in?: InputMaybe<Array<Scalars["vector"]["input"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  _lt?: InputMaybe<Scalars["vector"]["input"]>;
  _lte?: InputMaybe<Scalars["vector"]["input"]>;
  _neq?: InputMaybe<Scalars["vector"]["input"]>;
  _nin?: InputMaybe<Array<Scalars["vector"]["input"]>>;
};

/** columns and relationships of "votes" */
export type Votes = {
  __typename?: "votes";
  content_id: Scalars["uuid"]["output"];
  content_type: Scalars["String"]["output"];
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id: Scalars["uuid"]["output"];
  user_id: Scalars["uuid"]["output"];
  vote_type: Scalars["smallint"]["output"];
};

/** aggregated selection of "votes" */
export type VotesAggregate = {
  __typename?: "votes_aggregate";
  aggregate?: Maybe<VotesAggregateFields>;
  nodes: Array<Votes>;
};

/** aggregate fields of "votes" */
export type VotesAggregateFields = {
  __typename?: "votes_aggregate_fields";
  avg?: Maybe<VotesAvgFields>;
  count: Scalars["Int"]["output"];
  max?: Maybe<VotesMaxFields>;
  min?: Maybe<VotesMinFields>;
  stddev?: Maybe<VotesStddevFields>;
  stddev_pop?: Maybe<VotesStddevPopFields>;
  stddev_samp?: Maybe<VotesStddevSampFields>;
  sum?: Maybe<VotesSumFields>;
  var_pop?: Maybe<VotesVarPopFields>;
  var_samp?: Maybe<VotesVarSampFields>;
  variance?: Maybe<VotesVarianceFields>;
};

/** aggregate fields of "votes" */
export type VotesAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<VotesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export type VotesAvgFields = {
  __typename?: "votes_avg_fields";
  vote_type?: Maybe<Scalars["Float"]["output"]>;
};

/** Boolean expression to filter rows from the table "votes". All fields are combined with a logical 'AND'. */
export type VotesBoolExp = {
  _and?: InputMaybe<Array<VotesBoolExp>>;
  _not?: InputMaybe<VotesBoolExp>;
  _or?: InputMaybe<Array<VotesBoolExp>>;
  content_id?: InputMaybe<UuidComparisonExp>;
  content_type?: InputMaybe<StringComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  user_id?: InputMaybe<UuidComparisonExp>;
  vote_type?: InputMaybe<SmallintComparisonExp>;
};

/** unique or primary key constraints on table "votes" */
export enum VotesConstraint {
  /** unique or primary key constraint on columns "id" */
  VOTES_PKEY = "votes_pkey",
  /** unique or primary key constraint on columns "content_id", "user_id", "content_type" */
  VOTES_UNIQUE_USER_CONTENT_VOTE_IDX = "votes_unique_user_content_vote_idx",
}

/** input type for incrementing numeric columns in table "votes" */
export type VotesIncInput = {
  vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
};

/** input type for inserting data into table "votes" */
export type VotesInsertInput = {
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_type?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
};

/** aggregate max on columns */
export type VotesMaxFields = {
  __typename?: "votes_max_fields";
  content_id?: Maybe<Scalars["uuid"]["output"]>;
  content_type?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
  vote_type?: Maybe<Scalars["smallint"]["output"]>;
};

/** aggregate min on columns */
export type VotesMinFields = {
  __typename?: "votes_min_fields";
  content_id?: Maybe<Scalars["uuid"]["output"]>;
  content_type?: Maybe<Scalars["String"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  user_id?: Maybe<Scalars["uuid"]["output"]>;
  vote_type?: Maybe<Scalars["smallint"]["output"]>;
};

/** response of any mutation on the table "votes" */
export type VotesMutationResponse = {
  __typename?: "votes_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Votes>;
};

/** on_conflict condition type for table "votes" */
export type VotesOnConflict = {
  constraint: VotesConstraint;
  update_columns?: Array<VotesUpdateColumn>;
  where?: InputMaybe<VotesBoolExp>;
};

/** Ordering options when selecting data from "votes". */
export type VotesOrderBy = {
  content_id?: InputMaybe<OrderBy>;
  content_type?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  user_id?: InputMaybe<OrderBy>;
  vote_type?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: votes */
export type VotesPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** select columns of table "votes" */
export enum VotesSelectColumn {
  /** column name */
  CONTENT_ID = "content_id",
  /** column name */
  CONTENT_TYPE = "content_type",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  USER_ID = "user_id",
  /** column name */
  VOTE_TYPE = "vote_type",
}

/** input type for updating data in table "votes" */
export type VotesSetInput = {
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_type?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
};

/** aggregate stddev on columns */
export type VotesStddevFields = {
  __typename?: "votes_stddev_fields";
  vote_type?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_pop on columns */
export type VotesStddevPopFields = {
  __typename?: "votes_stddev_pop_fields";
  vote_type?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate stddev_samp on columns */
export type VotesStddevSampFields = {
  __typename?: "votes_stddev_samp_fields";
  vote_type?: Maybe<Scalars["Float"]["output"]>;
};

/** Streaming cursor of the table "votes" */
export type VotesStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: VotesStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type VotesStreamCursorValueInput = {
  content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  content_type?: InputMaybe<Scalars["String"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
};

/** aggregate sum on columns */
export type VotesSumFields = {
  __typename?: "votes_sum_fields";
  vote_type?: Maybe<Scalars["smallint"]["output"]>;
};

/** update columns of table "votes" */
export enum VotesUpdateColumn {
  /** column name */
  CONTENT_ID = "content_id",
  /** column name */
  CONTENT_TYPE = "content_type",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  USER_ID = "user_id",
  /** column name */
  VOTE_TYPE = "vote_type",
}

export type VotesUpdates = {
  /** increments the numeric columns with given value of the filtered values */
  _inc?: InputMaybe<VotesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<VotesSetInput>;
  /** filter the rows which have to be updated */
  where: VotesBoolExp;
};

/** aggregate var_pop on columns */
export type VotesVarPopFields = {
  __typename?: "votes_var_pop_fields";
  vote_type?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate var_samp on columns */
export type VotesVarSampFields = {
  __typename?: "votes_var_samp_fields";
  vote_type?: Maybe<Scalars["Float"]["output"]>;
};

/** aggregate variance on columns */
export type VotesVarianceFields = {
  __typename?: "votes_variance_fields";
  vote_type?: Maybe<Scalars["Float"]["output"]>;
};

/** columns and relationships of "workflows" */
export type Workflows = {
  __typename?: "workflows";
  completed_at?: Maybe<Scalars["timestamptz"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id: Scalars["uuid"]["output"];
  metadata?: Maybe<Scalars["jsonb"]["output"]>;
  name: Scalars["String"]["output"];
  started_at?: Maybe<Scalars["timestamptz"]["output"]>;
  status: Scalars["job_status"]["output"];
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** columns and relationships of "workflows" */
export type WorkflowsMetadataArgs = {
  path?: InputMaybe<Scalars["String"]["input"]>;
};

/** aggregated selection of "workflows" */
export type WorkflowsAggregate = {
  __typename?: "workflows_aggregate";
  aggregate?: Maybe<WorkflowsAggregateFields>;
  nodes: Array<Workflows>;
};

/** aggregate fields of "workflows" */
export type WorkflowsAggregateFields = {
  __typename?: "workflows_aggregate_fields";
  count: Scalars["Int"]["output"];
  max?: Maybe<WorkflowsMaxFields>;
  min?: Maybe<WorkflowsMinFields>;
};

/** aggregate fields of "workflows" */
export type WorkflowsAggregateFieldsCountArgs = {
  columns?: InputMaybe<Array<WorkflowsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export type WorkflowsAppendInput = {
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** Boolean expression to filter rows from the table "workflows". All fields are combined with a logical 'AND'. */
export type WorkflowsBoolExp = {
  _and?: InputMaybe<Array<WorkflowsBoolExp>>;
  _not?: InputMaybe<WorkflowsBoolExp>;
  _or?: InputMaybe<Array<WorkflowsBoolExp>>;
  completed_at?: InputMaybe<TimestamptzComparisonExp>;
  created_at?: InputMaybe<TimestamptzComparisonExp>;
  id?: InputMaybe<UuidComparisonExp>;
  metadata?: InputMaybe<JsonbComparisonExp>;
  name?: InputMaybe<StringComparisonExp>;
  started_at?: InputMaybe<TimestamptzComparisonExp>;
  status?: InputMaybe<JobStatusComparisonExp>;
  updated_at?: InputMaybe<TimestamptzComparisonExp>;
};

/** unique or primary key constraints on table "workflows" */
export enum WorkflowsConstraint {
  /** unique or primary key constraint on columns "id" */
  WORKFLOWS_PKEY = "workflows_pkey",
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export type WorkflowsDeleteAtPathInput = {
  metadata?: InputMaybe<Array<Scalars["String"]["input"]>>;
};

/** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
export type WorkflowsDeleteElemInput = {
  metadata?: InputMaybe<Scalars["Int"]["input"]>;
};

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export type WorkflowsDeleteKeyInput = {
  metadata?: InputMaybe<Scalars["String"]["input"]>;
};

/** input type for inserting data into table "workflows" */
export type WorkflowsInsertInput = {
  completed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  started_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  status?: InputMaybe<Scalars["job_status"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** aggregate max on columns */
export type WorkflowsMaxFields = {
  __typename?: "workflows_max_fields";
  completed_at?: Maybe<Scalars["timestamptz"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  started_at?: Maybe<Scalars["timestamptz"]["output"]>;
  status?: Maybe<Scalars["job_status"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** aggregate min on columns */
export type WorkflowsMinFields = {
  __typename?: "workflows_min_fields";
  completed_at?: Maybe<Scalars["timestamptz"]["output"]>;
  created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  id?: Maybe<Scalars["uuid"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  started_at?: Maybe<Scalars["timestamptz"]["output"]>;
  status?: Maybe<Scalars["job_status"]["output"]>;
  updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
};

/** response of any mutation on the table "workflows" */
export type WorkflowsMutationResponse = {
  __typename?: "workflows_mutation_response";
  /** number of rows affected by the mutation */
  affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  returning: Array<Workflows>;
};

/** on_conflict condition type for table "workflows" */
export type WorkflowsOnConflict = {
  constraint: WorkflowsConstraint;
  update_columns?: Array<WorkflowsUpdateColumn>;
  where?: InputMaybe<WorkflowsBoolExp>;
};

/** Ordering options when selecting data from "workflows". */
export type WorkflowsOrderBy = {
  completed_at?: InputMaybe<OrderBy>;
  created_at?: InputMaybe<OrderBy>;
  id?: InputMaybe<OrderBy>;
  metadata?: InputMaybe<OrderBy>;
  name?: InputMaybe<OrderBy>;
  started_at?: InputMaybe<OrderBy>;
  status?: InputMaybe<OrderBy>;
  updated_at?: InputMaybe<OrderBy>;
};

/** primary key columns input for table: workflows */
export type WorkflowsPkColumnsInput = {
  id: Scalars["uuid"]["input"];
};

/** prepend existing jsonb value of filtered columns with new jsonb value */
export type WorkflowsPrependInput = {
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
};

/** select columns of table "workflows" */
export enum WorkflowsSelectColumn {
  /** column name */
  COMPLETED_AT = "completed_at",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  METADATA = "metadata",
  /** column name */
  NAME = "name",
  /** column name */
  STARTED_AT = "started_at",
  /** column name */
  STATUS = "status",
  /** column name */
  UPDATED_AT = "updated_at",
}

/** input type for updating data in table "workflows" */
export type WorkflowsSetInput = {
  completed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  started_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  status?: InputMaybe<Scalars["job_status"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** Streaming cursor of the table "workflows" */
export type WorkflowsStreamCursorInput = {
  /** Stream column input with initial value */
  initial_value: WorkflowsStreamCursorValueInput;
  /** cursor ordering */
  ordering?: InputMaybe<CursorOrdering>;
};

/** Initial value of the column from where the streaming should start */
export type WorkflowsStreamCursorValueInput = {
  completed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  id?: InputMaybe<Scalars["uuid"]["input"]>;
  metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  started_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  status?: InputMaybe<Scalars["job_status"]["input"]>;
  updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
};

/** update columns of table "workflows" */
export enum WorkflowsUpdateColumn {
  /** column name */
  COMPLETED_AT = "completed_at",
  /** column name */
  CREATED_AT = "created_at",
  /** column name */
  ID = "id",
  /** column name */
  METADATA = "metadata",
  /** column name */
  NAME = "name",
  /** column name */
  STARTED_AT = "started_at",
  /** column name */
  STATUS = "status",
  /** column name */
  UPDATED_AT = "updated_at",
}

export type WorkflowsUpdates = {
  /** append existing jsonb value of filtered columns with new jsonb value */
  _append?: InputMaybe<WorkflowsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  _delete_at_path?: InputMaybe<WorkflowsDeleteAtPathInput>;
  /** delete the array element with specified index (negative integers count from the end). throws an error if top level container is not an array */
  _delete_elem?: InputMaybe<WorkflowsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  _delete_key?: InputMaybe<WorkflowsDeleteKeyInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  _prepend?: InputMaybe<WorkflowsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  _set?: InputMaybe<WorkflowsSetInput>;
  /** filter the rows which have to be updated */
  where: WorkflowsBoolExp;
};

export type FetchManyAdDailyMetricVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<AdDailyMetricsSelectColumn> | AdDailyMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdDailyMetricsOrderBy> | AdDailyMetricsOrderBy>;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
}>;

export type FetchManyAdDailyMetricResponse = {
  __typename?: "query_root";
  ad_daily_metrics: Array<{
    __typename?: "ad_daily_metrics";
    clicks?: number | null;
    created_at?: any | null;
    date: any;
    id: any;
    updated_at?: any | null;
    variant_id?: any | null;
    views?: number | null;
    ad_variant?: {
      __typename?: "ad_variants";
      active?: boolean | null;
      ad_id: any;
      content: any;
      created_at?: any | null;
      id: any;
      is_control?: boolean | null;
      performance_metrics?: any | null;
      updated_at?: any | null;
    } | null;
  }>;
};

export type CountAdDailyMetricVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<AdDailyMetricsSelectColumn> | AdDailyMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdDailyMetricsOrderBy> | AdDailyMetricsOrderBy>;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
}>;

export type CountAdDailyMetricResponse = {
  __typename?: "query_root";
  ad_daily_metrics_aggregate: {
    __typename?: "ad_daily_metrics_aggregate";
    nodes: Array<{
      __typename?: "ad_daily_metrics";
      clicks?: number | null;
      created_at?: any | null;
      date: any;
      id: any;
      updated_at?: any | null;
      variant_id?: any | null;
      views?: number | null;
    }>;
  };
};

export type FetchOneAdDailyMetricVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneAdDailyMetricResponse = {
  __typename?: "query_root";
  ad_daily_metrics_by_pk?: {
    __typename?: "ad_daily_metrics";
    clicks?: number | null;
    created_at?: any | null;
    date: any;
    id: any;
    updated_at?: any | null;
    variant_id?: any | null;
    views?: number | null;
    ad_variant?: {
      __typename?: "ad_variants";
      active?: boolean | null;
      ad_id: any;
      content: any;
      created_at?: any | null;
      id: any;
      is_control?: boolean | null;
      performance_metrics?: any | null;
      updated_at?: any | null;
    } | null;
  } | null;
};

export type FetchManyAdPackageVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<AdPackagesSelectColumn> | AdPackagesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdPackagesOrderBy> | AdPackagesOrderBy>;
  where?: InputMaybe<AdPackagesBoolExp>;
}>;

export type FetchManyAdPackageResponse = {
  __typename?: "query_root";
  ad_packages: Array<{
    __typename?: "ad_packages";
    active?: boolean | null;
    avg_roi?: any | null;
    created_at?: any | null;
    description: string;
    expected_ctr?: any | null;
    features: Array<string>;
    id: any;
    name: string;
    position: string;
    price: any;
    updated_at?: any | null;
    view_frequency?: any | null;
    ads: Array<{
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    }>;
  }>;
};

export type CountAdPackageVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<AdPackagesSelectColumn> | AdPackagesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdPackagesOrderBy> | AdPackagesOrderBy>;
  where?: InputMaybe<AdPackagesBoolExp>;
}>;

export type CountAdPackageResponse = {
  __typename?: "query_root";
  ad_packages_aggregate: {
    __typename?: "ad_packages_aggregate";
    nodes: Array<{
      __typename?: "ad_packages";
      active?: boolean | null;
      avg_roi?: any | null;
      created_at?: any | null;
      description: string;
      expected_ctr?: any | null;
      features: Array<string>;
      id: any;
      name: string;
      position: string;
      price: any;
      updated_at?: any | null;
      view_frequency?: any | null;
    }>;
  };
};

export type FetchOneAdPackageVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneAdPackageResponse = {
  __typename?: "query_root";
  ad_packages_by_pk?: {
    __typename?: "ad_packages";
    active?: boolean | null;
    avg_roi?: any | null;
    created_at?: any | null;
    description: string;
    expected_ctr?: any | null;
    features: Array<string>;
    id: any;
    name: string;
    position: string;
    price: any;
    updated_at?: any | null;
    view_frequency?: any | null;
    ads: Array<{
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    }>;
  } | null;
};

export type FetchManyAdVariantVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<AdVariantsSelectColumn> | AdVariantsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdVariantsOrderBy> | AdVariantsOrderBy>;
  where?: InputMaybe<AdVariantsBoolExp>;
}>;

export type FetchManyAdVariantResponse = {
  __typename?: "query_root";
  ad_variants: Array<{
    __typename?: "ad_variants";
    active?: boolean | null;
    ad_id: any;
    content: any;
    created_at?: any | null;
    id: any;
    is_control?: boolean | null;
    performance_metrics?: any | null;
    updated_at?: any | null;
    ad: {
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    };
    ad_daily_metrics: Array<{
      __typename?: "ad_daily_metrics";
      clicks?: number | null;
      created_at?: any | null;
      date: any;
      id: any;
      updated_at?: any | null;
      variant_id?: any | null;
      views?: number | null;
    }>;
  }>;
};

export type CountAdVariantVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<AdVariantsSelectColumn> | AdVariantsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdVariantsOrderBy> | AdVariantsOrderBy>;
  where?: InputMaybe<AdVariantsBoolExp>;
}>;

export type CountAdVariantResponse = {
  __typename?: "query_root";
  ad_variants_aggregate: {
    __typename?: "ad_variants_aggregate";
    nodes: Array<{
      __typename?: "ad_variants";
      active?: boolean | null;
      ad_id: any;
      content: any;
      created_at?: any | null;
      id: any;
      is_control?: boolean | null;
      performance_metrics?: any | null;
      updated_at?: any | null;
    }>;
  };
};

export type FetchOneAdVariantVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneAdVariantResponse = {
  __typename?: "query_root";
  ad_variants_by_pk?: {
    __typename?: "ad_variants";
    active?: boolean | null;
    ad_id: any;
    content: any;
    created_at?: any | null;
    id: any;
    is_control?: boolean | null;
    performance_metrics?: any | null;
    updated_at?: any | null;
    ad: {
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    };
    ad_daily_metrics: Array<{
      __typename?: "ad_daily_metrics";
      clicks?: number | null;
      created_at?: any | null;
      date: any;
      id: any;
      updated_at?: any | null;
      variant_id?: any | null;
      views?: number | null;
    }>;
  } | null;
};

export type FetchManyAddressVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<AddressesSelectColumn> | AddressesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AddressesOrderBy> | AddressesOrderBy>;
  where?: InputMaybe<AddressesBoolExp>;
}>;

export type FetchManyAddressResponse = {
  __typename?: "query_root";
  addresses: Array<{
    __typename?: "addresses";
    address_type?: any | null;
    city_id: number;
    company_id?: any | null;
    country_id: number;
    created_at?: any | null;
    id: number;
    is_primary?: boolean | null;
    name?: string | null;
    street1: string;
    street2?: string | null;
    updated_at?: any | null;
    user_id?: any | null;
    city: {
      __typename?: "cities";
      country_id: number;
      id: number;
      name: string;
      state?: string | null;
    };
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    country: {
      __typename?: "countries";
      code: string;
      code_3?: string | null;
      id: number;
      name: string;
    };
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  }>;
};

export type CountAddressVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<AddressesSelectColumn> | AddressesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AddressesOrderBy> | AddressesOrderBy>;
  where?: InputMaybe<AddressesBoolExp>;
}>;

export type CountAddressResponse = {
  __typename?: "query_root";
  addresses_aggregate: {
    __typename?: "addresses_aggregate";
    nodes: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
  };
};

export type FetchOneAddressVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneAddressResponse = {
  __typename?: "query_root";
  addresses_by_pk?: {
    __typename?: "addresses";
    address_type?: any | null;
    city_id: number;
    company_id?: any | null;
    country_id: number;
    created_at?: any | null;
    id: number;
    is_primary?: boolean | null;
    name?: string | null;
    street1: string;
    street2?: string | null;
    updated_at?: any | null;
    user_id?: any | null;
    city: {
      __typename?: "cities";
      country_id: number;
      id: number;
      name: string;
      state?: string | null;
    };
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    country: {
      __typename?: "countries";
      code: string;
      code_3?: string | null;
      id: number;
      name: string;
    };
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type FetchManyAdVariables = Exact<{
  distinct_on?: InputMaybe<Array<AdsSelectColumn> | AdsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdsOrderBy> | AdsOrderBy>;
  where?: InputMaybe<AdsBoolExp>;
}>;

export type FetchManyAdResponse = {
  __typename?: "query_root";
  ads: Array<{
    __typename?: "ads";
    active?: boolean | null;
    company_id?: any | null;
    created_at?: any | null;
    end_date: any;
    id: any;
    package_id?: any | null;
    start_date: any;
    updated_at?: any | null;
    ad_package?: {
      __typename?: "ad_packages";
      active?: boolean | null;
      avg_roi?: any | null;
      created_at?: any | null;
      description: string;
      expected_ctr?: any | null;
      features: Array<string>;
      id: any;
      name: string;
      position: string;
      price: any;
      updated_at?: any | null;
      view_frequency?: any | null;
    } | null;
    ad_variants: Array<{
      __typename?: "ad_variants";
      active?: boolean | null;
      ad_id: any;
      content: any;
      created_at?: any | null;
      id: any;
      is_control?: boolean | null;
      performance_metrics?: any | null;
      updated_at?: any | null;
    }>;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  }>;
};

export type CountAdVariables = Exact<{
  distinct_on?: InputMaybe<Array<AdsSelectColumn> | AdsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<AdsOrderBy> | AdsOrderBy>;
  where?: InputMaybe<AdsBoolExp>;
}>;

export type CountAdResponse = {
  __typename?: "query_root";
  ads_aggregate: {
    __typename?: "ads_aggregate";
    nodes: Array<{
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    }>;
  };
};

export type FetchOneAdVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneAdResponse = {
  __typename?: "query_root";
  ads_by_pk?: {
    __typename?: "ads";
    active?: boolean | null;
    company_id?: any | null;
    created_at?: any | null;
    end_date: any;
    id: any;
    package_id?: any | null;
    start_date: any;
    updated_at?: any | null;
    ad_package?: {
      __typename?: "ad_packages";
      active?: boolean | null;
      avg_roi?: any | null;
      created_at?: any | null;
      description: string;
      expected_ctr?: any | null;
      features: Array<string>;
      id: any;
      name: string;
      position: string;
      price: any;
      updated_at?: any | null;
      view_frequency?: any | null;
    } | null;
    ad_variants: Array<{
      __typename?: "ad_variants";
      active?: boolean | null;
      ad_id: any;
      content: any;
      created_at?: any | null;
      id: any;
      is_control?: boolean | null;
      performance_metrics?: any | null;
      updated_at?: any | null;
    }>;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type FetchManyBlacklistedDomainVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<BlacklistedDomainsSelectColumn> | BlacklistedDomainsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<BlacklistedDomainsOrderBy> | BlacklistedDomainsOrderBy
  >;
  where?: InputMaybe<BlacklistedDomainsBoolExp>;
}>;

export type FetchManyBlacklistedDomainResponse = {
  __typename?: "query_root";
  blacklisted_domains: Array<{
    __typename?: "blacklisted_domains";
    created_at: any;
    id: any;
    reason?: string | null;
    url: string;
  }>;
};

export type CountBlacklistedDomainVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<BlacklistedDomainsSelectColumn> | BlacklistedDomainsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<BlacklistedDomainsOrderBy> | BlacklistedDomainsOrderBy
  >;
  where?: InputMaybe<BlacklistedDomainsBoolExp>;
}>;

export type CountBlacklistedDomainResponse = {
  __typename?: "query_root";
  blacklisted_domains_aggregate: {
    __typename?: "blacklisted_domains_aggregate";
    nodes: Array<{
      __typename?: "blacklisted_domains";
      created_at: any;
      id: any;
      reason?: string | null;
      url: string;
    }>;
  };
};

export type FetchOneBlacklistedDomainVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneBlacklistedDomainResponse = {
  __typename?: "query_root";
  blacklisted_domains_by_pk?: {
    __typename?: "blacklisted_domains";
    created_at: any;
    id: any;
    reason?: string | null;
    url: string;
  } | null;
};

export type FetchManyBlacklistedUrlVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<BlacklistedUrlsSelectColumn> | BlacklistedUrlsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlacklistedUrlsOrderBy> | BlacklistedUrlsOrderBy>;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
}>;

export type FetchManyBlacklistedUrlResponse = {
  __typename?: "query_root";
  blacklisted_urls: Array<{
    __typename?: "blacklisted_urls";
    company_id?: any | null;
    created_at?: any | null;
    id: number;
    reason?: string | null;
    url: string;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  }>;
};

export type CountBlacklistedUrlVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<BlacklistedUrlsSelectColumn> | BlacklistedUrlsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlacklistedUrlsOrderBy> | BlacklistedUrlsOrderBy>;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
}>;

export type CountBlacklistedUrlResponse = {
  __typename?: "query_root";
  blacklisted_urls_aggregate: {
    __typename?: "blacklisted_urls_aggregate";
    nodes: Array<{
      __typename?: "blacklisted_urls";
      company_id?: any | null;
      created_at?: any | null;
      id: number;
      reason?: string | null;
      url: string;
    }>;
  };
};

export type FetchOneBlacklistedUrlVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneBlacklistedUrlResponse = {
  __typename?: "query_root";
  blacklisted_urls_by_pk?: {
    __typename?: "blacklisted_urls";
    company_id?: any | null;
    created_at?: any | null;
    id: number;
    reason?: string | null;
    url: string;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type FetchManyBlockedIpVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<BlockedIpsSelectColumn> | BlockedIpsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlockedIpsOrderBy> | BlockedIpsOrderBy>;
  where?: InputMaybe<BlockedIpsBoolExp>;
}>;

export type FetchManyBlockedIpResponse = {
  __typename?: "query_root";
  blocked_ips: Array<{
    __typename?: "blocked_ips";
    blocked_at?: any | null;
    blocked_until: any;
    created_at?: any | null;
    failed_attempts?: number | null;
    id: any;
    ip_address: any;
    reason?: string | null;
    updated_at?: any | null;
  }>;
};

export type CountBlockedIpVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<BlockedIpsSelectColumn> | BlockedIpsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BlockedIpsOrderBy> | BlockedIpsOrderBy>;
  where?: InputMaybe<BlockedIpsBoolExp>;
}>;

export type CountBlockedIpResponse = {
  __typename?: "query_root";
  blocked_ips_aggregate: {
    __typename?: "blocked_ips_aggregate";
    nodes: Array<{
      __typename?: "blocked_ips";
      blocked_at?: any | null;
      blocked_until: any;
      created_at?: any | null;
      failed_attempts?: number | null;
      id: any;
      ip_address: any;
      reason?: string | null;
      updated_at?: any | null;
    }>;
  };
};

export type FetchOneBlockedIpVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneBlockedIpResponse = {
  __typename?: "query_root";
  blocked_ips_by_pk?: {
    __typename?: "blocked_ips";
    blocked_at?: any | null;
    blocked_until: any;
    created_at?: any | null;
    failed_attempts?: number | null;
    id: any;
    ip_address: any;
    reason?: string | null;
    updated_at?: any | null;
  } | null;
};

export type FetchManyBookmarkFolderVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<BookmarkFoldersSelectColumn> | BookmarkFoldersSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarkFoldersOrderBy> | BookmarkFoldersOrderBy>;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
}>;

export type FetchManyBookmarkFolderResponse = {
  __typename?: "query_root";
  bookmark_folders: Array<{
    __typename?: "bookmark_folders";
    color?: string | null;
    created_at?: any | null;
    id: any;
    is_default?: boolean | null;
    is_favorite?: boolean | null;
    name: string;
    parent_id?: any | null;
    path?: any | null;
    position?: number | null;
    updated_at?: any | null;
    user_id: any;
    bookmarks: Array<{
      __typename?: "bookmarks";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      folder_id?: any | null;
      id: any;
      metadata?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  }>;
};

export type CountBookmarkFolderVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<BookmarkFoldersSelectColumn> | BookmarkFoldersSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarkFoldersOrderBy> | BookmarkFoldersOrderBy>;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
}>;

export type CountBookmarkFolderResponse = {
  __typename?: "query_root";
  bookmark_folders_aggregate: {
    __typename?: "bookmark_folders_aggregate";
    nodes: Array<{
      __typename?: "bookmark_folders";
      color?: string | null;
      created_at?: any | null;
      id: any;
      is_default?: boolean | null;
      is_favorite?: boolean | null;
      name: string;
      parent_id?: any | null;
      path?: any | null;
      position?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  };
};

export type FetchOneBookmarkFolderVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneBookmarkFolderResponse = {
  __typename?: "query_root";
  bookmark_folders_by_pk?: {
    __typename?: "bookmark_folders";
    color?: string | null;
    created_at?: any | null;
    id: any;
    is_default?: boolean | null;
    is_favorite?: boolean | null;
    name: string;
    parent_id?: any | null;
    path?: any | null;
    position?: number | null;
    updated_at?: any | null;
    user_id: any;
    bookmarks: Array<{
      __typename?: "bookmarks";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      folder_id?: any | null;
      id: any;
      metadata?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  } | null;
};

export type FetchManyBookmarkVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<BookmarksSelectColumn> | BookmarksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarksOrderBy> | BookmarksOrderBy>;
  where?: InputMaybe<BookmarksBoolExp>;
}>;

export type FetchManyBookmarkResponse = {
  __typename?: "query_root";
  bookmarks: Array<{
    __typename?: "bookmarks";
    content_id: any;
    content_type: string;
    created_at?: any | null;
    folder_id?: any | null;
    id: any;
    metadata?: any | null;
    updated_at?: any | null;
    user_id: any;
    bookmark_folder?: {
      __typename?: "bookmark_folders";
      color?: string | null;
      created_at?: any | null;
      id: any;
      is_default?: boolean | null;
      is_favorite?: boolean | null;
      name: string;
      parent_id?: any | null;
      path?: any | null;
      position?: number | null;
      updated_at?: any | null;
      user_id: any;
    } | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  }>;
};

export type CountBookmarkVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<BookmarksSelectColumn> | BookmarksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BookmarksOrderBy> | BookmarksOrderBy>;
  where?: InputMaybe<BookmarksBoolExp>;
}>;

export type CountBookmarkResponse = {
  __typename?: "query_root";
  bookmarks_aggregate: {
    __typename?: "bookmarks_aggregate";
    nodes: Array<{
      __typename?: "bookmarks";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      folder_id?: any | null;
      id: any;
      metadata?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  };
};

export type FetchOneBookmarkVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneBookmarkResponse = {
  __typename?: "query_root";
  bookmarks_by_pk?: {
    __typename?: "bookmarks";
    content_id: any;
    content_type: string;
    created_at?: any | null;
    folder_id?: any | null;
    id: any;
    metadata?: any | null;
    updated_at?: any | null;
    user_id: any;
    bookmark_folder?: {
      __typename?: "bookmark_folders";
      color?: string | null;
      created_at?: any | null;
      id: any;
      is_default?: boolean | null;
      is_favorite?: boolean | null;
      name: string;
      parent_id?: any | null;
      path?: any | null;
      position?: number | null;
      updated_at?: any | null;
      user_id: any;
    } | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type FetchManyBusinessDomainVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<BusinessDomainsSelectColumn> | BusinessDomainsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BusinessDomainsOrderBy> | BusinessDomainsOrderBy>;
  where?: InputMaybe<BusinessDomainsBoolExp>;
}>;

export type FetchManyBusinessDomainResponse = {
  __typename?: "query_root";
  business_domains: Array<{
    __typename?: "business_domains";
    created_at?: any | null;
    description?: string | null;
    id: any;
    name: string;
    parent_id?: any | null;
    slug: string;
    updated_at?: any | null;
    categorized_urls: Array<{
      __typename?: "categorized_urls";
      categorizer_version: string;
      company_id?: any | null;
      confidence: any;
      content_hash?: string | null;
      created_at?: any | null;
      domain_id: any;
      found_on?: string | null;
      id: any;
      priority?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
  }>;
};

export type CountBusinessDomainVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<BusinessDomainsSelectColumn> | BusinessDomainsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<BusinessDomainsOrderBy> | BusinessDomainsOrderBy>;
  where?: InputMaybe<BusinessDomainsBoolExp>;
}>;

export type CountBusinessDomainResponse = {
  __typename?: "query_root";
  business_domains_aggregate: {
    __typename?: "business_domains_aggregate";
    nodes: Array<{
      __typename?: "business_domains";
      created_at?: any | null;
      description?: string | null;
      id: any;
      name: string;
      parent_id?: any | null;
      slug: string;
      updated_at?: any | null;
    }>;
  };
};

export type FetchOneBusinessDomainVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneBusinessDomainResponse = {
  __typename?: "query_root";
  business_domains_by_pk?: {
    __typename?: "business_domains";
    created_at?: any | null;
    description?: string | null;
    id: any;
    name: string;
    parent_id?: any | null;
    slug: string;
    updated_at?: any | null;
    categorized_urls: Array<{
      __typename?: "categorized_urls";
      categorizer_version: string;
      company_id?: any | null;
      confidence: any;
      content_hash?: string | null;
      created_at?: any | null;
      domain_id: any;
      found_on?: string | null;
      id: any;
      priority?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
  } | null;
};

export type FetchManyCategoryVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CategoriesSelectColumn> | CategoriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategoriesOrderBy> | CategoriesOrderBy>;
  where?: InputMaybe<CategoriesBoolExp>;
}>;

export type FetchManyCategoryResponse = {
  __typename?: "query_root";
  categories: Array<{
    __typename?: "categories";
    body?: string | null;
    created_at: any;
    document_id?: string | null;
    id: any;
    locale?: string | null;
    name: string;
    published_at?: string | null;
    updated_at?: any | null;
    companies: Array<{
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    }>;
    content_categories: Array<{
      __typename?: "content_categories";
      category_id: any;
      content_id: any;
      is_primary: boolean;
    }>;
    feed_categories: Array<{
      __typename?: "feed_categories";
      category_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    news: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
  }>;
};

export type CountCategoryVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CategoriesSelectColumn> | CategoriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategoriesOrderBy> | CategoriesOrderBy>;
  where?: InputMaybe<CategoriesBoolExp>;
}>;

export type CountCategoryResponse = {
  __typename?: "query_root";
  categories_aggregate: {
    __typename?: "categories_aggregate";
    nodes: Array<{
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    }>;
  };
};

export type FetchOneCategoryVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneCategoryResponse = {
  __typename?: "query_root";
  categories_by_pk?: {
    __typename?: "categories";
    body?: string | null;
    created_at: any;
    document_id?: string | null;
    id: any;
    locale?: string | null;
    name: string;
    published_at?: string | null;
    updated_at?: any | null;
    companies: Array<{
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    }>;
    content_categories: Array<{
      __typename?: "content_categories";
      category_id: any;
      content_id: any;
      is_primary: boolean;
    }>;
    feed_categories: Array<{
      __typename?: "feed_categories";
      category_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    news: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
  } | null;
};

export type FetchManyCategorizedUrlVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CategorizedUrlsSelectColumn> | CategorizedUrlsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategorizedUrlsOrderBy> | CategorizedUrlsOrderBy>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
}>;

export type FetchManyCategorizedUrlResponse = {
  __typename?: "query_root";
  categorized_urls: Array<{
    __typename?: "categorized_urls";
    categorizer_version: string;
    company_id?: any | null;
    confidence: any;
    content_hash?: string | null;
    created_at?: any | null;
    domain_id: any;
    found_on?: string | null;
    id: any;
    priority?: any | null;
    updated_at?: any | null;
    url: string;
    business_domain: {
      __typename?: "business_domains";
      created_at?: any | null;
      description?: string | null;
      id: any;
      name: string;
      parent_id?: any | null;
      slug: string;
      updated_at?: any | null;
    };
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  }>;
};

export type CountCategorizedUrlVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CategorizedUrlsSelectColumn> | CategorizedUrlsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CategorizedUrlsOrderBy> | CategorizedUrlsOrderBy>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
}>;

export type CountCategorizedUrlResponse = {
  __typename?: "query_root";
  categorized_urls_aggregate: {
    __typename?: "categorized_urls_aggregate";
    nodes: Array<{
      __typename?: "categorized_urls";
      categorizer_version: string;
      company_id?: any | null;
      confidence: any;
      content_hash?: string | null;
      created_at?: any | null;
      domain_id: any;
      found_on?: string | null;
      id: any;
      priority?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
  };
};

export type FetchOneCategorizedUrlVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneCategorizedUrlResponse = {
  __typename?: "query_root";
  categorized_urls_by_pk?: {
    __typename?: "categorized_urls";
    categorizer_version: string;
    company_id?: any | null;
    confidence: any;
    content_hash?: string | null;
    created_at?: any | null;
    domain_id: any;
    found_on?: string | null;
    id: any;
    priority?: any | null;
    updated_at?: any | null;
    url: string;
    business_domain: {
      __typename?: "business_domains";
      created_at?: any | null;
      description?: string | null;
      id: any;
      name: string;
      parent_id?: any | null;
      slug: string;
      updated_at?: any | null;
    };
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type FetchManyCircuitBreakerStateVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CircuitBreakerStatesSelectColumn> | CircuitBreakerStatesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<CircuitBreakerStatesOrderBy> | CircuitBreakerStatesOrderBy
  >;
  where?: InputMaybe<CircuitBreakerStatesBoolExp>;
}>;

export type FetchManyCircuitBreakerStateResponse = {
  __typename?: "query_root";
  circuit_breaker_states: Array<{
    __typename?: "circuit_breaker_states";
    created_at?: any | null;
    failure_count?: number | null;
    id: any;
    job_name: string;
    last_failure?: any | null;
    last_success?: any | null;
    state: string;
    updated_at?: any | null;
  }>;
};

export type CountCircuitBreakerStateVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CircuitBreakerStatesSelectColumn> | CircuitBreakerStatesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<CircuitBreakerStatesOrderBy> | CircuitBreakerStatesOrderBy
  >;
  where?: InputMaybe<CircuitBreakerStatesBoolExp>;
}>;

export type CountCircuitBreakerStateResponse = {
  __typename?: "query_root";
  circuit_breaker_states_aggregate: {
    __typename?: "circuit_breaker_states_aggregate";
    nodes: Array<{
      __typename?: "circuit_breaker_states";
      created_at?: any | null;
      failure_count?: number | null;
      id: any;
      job_name: string;
      last_failure?: any | null;
      last_success?: any | null;
      state: string;
      updated_at?: any | null;
    }>;
  };
};

export type FetchOneCircuitBreakerStateVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneCircuitBreakerStateResponse = {
  __typename?: "query_root";
  circuit_breaker_states_by_pk?: {
    __typename?: "circuit_breaker_states";
    created_at?: any | null;
    failure_count?: number | null;
    id: any;
    job_name: string;
    last_failure?: any | null;
    last_success?: any | null;
    state: string;
    updated_at?: any | null;
  } | null;
};

export type FetchManyCityVariables = Exact<{
  distinct_on?: InputMaybe<Array<CitiesSelectColumn> | CitiesSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CitiesOrderBy> | CitiesOrderBy>;
  where?: InputMaybe<CitiesBoolExp>;
}>;

export type FetchManyCityResponse = {
  __typename?: "query_root";
  cities: Array<{
    __typename?: "cities";
    country_id: number;
    id: number;
    name: string;
    state?: string | null;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    country: {
      __typename?: "countries";
      code: string;
      code_3?: string | null;
      id: number;
      name: string;
    };
  }>;
};

export type CountCityVariables = Exact<{
  distinct_on?: InputMaybe<Array<CitiesSelectColumn> | CitiesSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CitiesOrderBy> | CitiesOrderBy>;
  where?: InputMaybe<CitiesBoolExp>;
}>;

export type CountCityResponse = {
  __typename?: "query_root";
  cities_aggregate: {
    __typename?: "cities_aggregate";
    nodes: Array<{
      __typename?: "cities";
      country_id: number;
      id: number;
      name: string;
      state?: string | null;
    }>;
  };
};

export type FetchOneCityVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCityResponse = {
  __typename?: "query_root";
  cities_by_pk?: {
    __typename?: "cities";
    country_id: number;
    id: number;
    name: string;
    state?: string | null;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    country: {
      __typename?: "countries";
      code: string;
      code_3?: string | null;
      id: number;
      name: string;
    };
  } | null;
};

export type FetchManyCommentVariables = Exact<{
  distinct_on?: InputMaybe<Array<CommentsSelectColumn> | CommentsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CommentsOrderBy> | CommentsOrderBy>;
  where?: InputMaybe<CommentsBoolExp>;
}>;

export type FetchManyCommentResponse = {
  __typename?: "query_root";
  comments: Array<{
    __typename?: "comments";
    content: string;
    content_id: any;
    content_type: any;
    created_at?: any | null;
    id: any;
    parent_comment_id?: any | null;
    updated_at?: any | null;
    user_id: any;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  }>;
};

export type CountCommentVariables = Exact<{
  distinct_on?: InputMaybe<Array<CommentsSelectColumn> | CommentsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CommentsOrderBy> | CommentsOrderBy>;
  where?: InputMaybe<CommentsBoolExp>;
}>;

export type CountCommentResponse = {
  __typename?: "query_root";
  comments_aggregate: {
    __typename?: "comments_aggregate";
    nodes: Array<{
      __typename?: "comments";
      content: string;
      content_id: any;
      content_type: any;
      created_at?: any | null;
      id: any;
      parent_comment_id?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  };
};

export type FetchOneCommentVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneCommentResponse = {
  __typename?: "query_root";
  comments_by_pk?: {
    __typename?: "comments";
    content: string;
    content_id: any;
    content_type: any;
    created_at?: any | null;
    id: any;
    parent_comment_id?: any | null;
    updated_at?: any | null;
    user_id: any;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type FetchManyCompanyVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CompaniesSelectColumn> | CompaniesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompaniesOrderBy> | CompaniesOrderBy>;
  where?: InputMaybe<CompaniesBoolExp>;
}>;

export type FetchManyCompanyResponse = {
  __typename?: "query_root";
  companies: Array<{
    __typename?: "companies";
    category?: string | null;
    category_id?: any | null;
    content_status: any;
    created_at?: any | null;
    description?: string | null;
    failed_count?: any | null;
    founding_year?: any | null;
    id: any;
    is_english?: boolean | null;
    is_government?: boolean | null;
    keywords?: any | null;
    logo_url?: string | null;
    name?: string | null;
    scrape_frequency?: any | null;
    scrape_rating?: any | null;
    scraped_at?: any | null;
    social_media_id?: number | null;
    updated_at?: any | null;
    url: string;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    ads: Array<{
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    }>;
    blacklisted_urls: Array<{
      __typename?: "blacklisted_urls";
      company_id?: any | null;
      created_at?: any | null;
      id: number;
      reason?: string | null;
      url: string;
    }>;
    categorized_urls: Array<{
      __typename?: "categorized_urls";
      categorizer_version: string;
      company_id?: any | null;
      confidence: any;
      content_hash?: string | null;
      created_at?: any | null;
      domain_id: any;
      found_on?: string | null;
      id: any;
      priority?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
    categoryByCategoryId?: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    } | null;
    company_contacts: Array<{
      __typename?: "company_contacts";
      company_id?: any | null;
      contact_id: number;
      created_at: any;
      id: number;
      updated_at: any;
    }>;
    company_extras: Array<{
      __typename?: "company_extras";
      body?: string | null;
      category: string;
      company_id?: any | null;
      created_at: any;
      found_count?: number | null;
      id: number;
      level: any;
      review?: any | null;
      success?: boolean | null;
      updated_at: any;
      url: string;
    }>;
    contacts: Array<{
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    content_sources: Array<{
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
    news: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
    social_medium?: {
      __typename?: "social_media";
      created_at?: any | null;
      facebook_url?: string | null;
      id: number;
      instagram_url?: string | null;
      linkedin_url?: string | null;
      twitter_url?: string | null;
      updated_at?: any | null;
      youtube_url?: string | null;
    } | null;
  }>;
};

export type CountCompanyVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CompaniesSelectColumn> | CompaniesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompaniesOrderBy> | CompaniesOrderBy>;
  where?: InputMaybe<CompaniesBoolExp>;
}>;

export type CountCompanyResponse = {
  __typename?: "query_root";
  companies_aggregate: {
    __typename?: "companies_aggregate";
    nodes: Array<{
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    }>;
  };
};

export type FetchOneCompanyVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneCompanyResponse = {
  __typename?: "query_root";
  companies_by_pk?: {
    __typename?: "companies";
    category?: string | null;
    category_id?: any | null;
    content_status: any;
    created_at?: any | null;
    description?: string | null;
    failed_count?: any | null;
    founding_year?: any | null;
    id: any;
    is_english?: boolean | null;
    is_government?: boolean | null;
    keywords?: any | null;
    logo_url?: string | null;
    name?: string | null;
    scrape_frequency?: any | null;
    scrape_rating?: any | null;
    scraped_at?: any | null;
    social_media_id?: number | null;
    updated_at?: any | null;
    url: string;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    ads: Array<{
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    }>;
    blacklisted_urls: Array<{
      __typename?: "blacklisted_urls";
      company_id?: any | null;
      created_at?: any | null;
      id: number;
      reason?: string | null;
      url: string;
    }>;
    categorized_urls: Array<{
      __typename?: "categorized_urls";
      categorizer_version: string;
      company_id?: any | null;
      confidence: any;
      content_hash?: string | null;
      created_at?: any | null;
      domain_id: any;
      found_on?: string | null;
      id: any;
      priority?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
    categoryByCategoryId?: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    } | null;
    company_contacts: Array<{
      __typename?: "company_contacts";
      company_id?: any | null;
      contact_id: number;
      created_at: any;
      id: number;
      updated_at: any;
    }>;
    company_extras: Array<{
      __typename?: "company_extras";
      body?: string | null;
      category: string;
      company_id?: any | null;
      created_at: any;
      found_count?: number | null;
      id: number;
      level: any;
      review?: any | null;
      success?: boolean | null;
      updated_at: any;
      url: string;
    }>;
    contacts: Array<{
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    content_sources: Array<{
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
    news: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
    social_medium?: {
      __typename?: "social_media";
      created_at?: any | null;
      facebook_url?: string | null;
      id: number;
      instagram_url?: string | null;
      linkedin_url?: string | null;
      twitter_url?: string | null;
      updated_at?: any | null;
      youtube_url?: string | null;
    } | null;
  } | null;
};

export type FetchManyCompanyContactVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CompanyContactsSelectColumn> | CompanyContactsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyContactsOrderBy> | CompanyContactsOrderBy>;
  where?: InputMaybe<CompanyContactsBoolExp>;
}>;

export type FetchManyCompanyContactResponse = {
  __typename?: "query_root";
  company_contacts: Array<{
    __typename?: "company_contacts";
    company_id?: any | null;
    contact_id: number;
    created_at: any;
    id: number;
    updated_at: any;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    contact: {
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    };
  }>;
};

export type CountCompanyContactVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CompanyContactsSelectColumn> | CompanyContactsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyContactsOrderBy> | CompanyContactsOrderBy>;
  where?: InputMaybe<CompanyContactsBoolExp>;
}>;

export type CountCompanyContactResponse = {
  __typename?: "query_root";
  company_contacts_aggregate: {
    __typename?: "company_contacts_aggregate";
    nodes: Array<{
      __typename?: "company_contacts";
      company_id?: any | null;
      contact_id: number;
      created_at: any;
      id: number;
      updated_at: any;
    }>;
  };
};

export type FetchOneCompanyContactVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCompanyContactResponse = {
  __typename?: "query_root";
  company_contacts_by_pk?: {
    __typename?: "company_contacts";
    company_id?: any | null;
    contact_id: number;
    created_at: any;
    id: number;
    updated_at: any;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    contact: {
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    };
  } | null;
};

export type FetchManyCompanyEmployeeVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CompanyEmployeesSelectColumn> | CompanyEmployeesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<CompanyEmployeesOrderBy> | CompanyEmployeesOrderBy
  >;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
}>;

export type FetchManyCompanyEmployeeResponse = {
  __typename?: "query_root";
  company_employees: Array<{
    __typename?: "company_employees";
    access_level: any;
    company_id?: any | null;
    created_at?: any | null;
    end_date?: any | null;
    id: any;
    job_description?: string | null;
    role: string;
    start_date?: any | null;
    status?: boolean | null;
    updated_at?: any | null;
    user_id: any;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  }>;
};

export type CountCompanyEmployeeVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CompanyEmployeesSelectColumn> | CompanyEmployeesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<CompanyEmployeesOrderBy> | CompanyEmployeesOrderBy
  >;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
}>;

export type CountCompanyEmployeeResponse = {
  __typename?: "query_root";
  company_employees_aggregate: {
    __typename?: "company_employees_aggregate";
    nodes: Array<{
      __typename?: "company_employees";
      access_level: any;
      company_id?: any | null;
      created_at?: any | null;
      end_date?: any | null;
      id: any;
      job_description?: string | null;
      role: string;
      start_date?: any | null;
      status?: boolean | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  };
};

export type FetchOneCompanyEmployeeVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneCompanyEmployeeResponse = {
  __typename?: "query_root";
  company_employees_by_pk?: {
    __typename?: "company_employees";
    access_level: any;
    company_id?: any | null;
    created_at?: any | null;
    end_date?: any | null;
    id: any;
    job_description?: string | null;
    role: string;
    start_date?: any | null;
    status?: boolean | null;
    updated_at?: any | null;
    user_id: any;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type FetchManyCompanyExtraVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CompanyExtrasSelectColumn> | CompanyExtrasSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyExtrasOrderBy> | CompanyExtrasOrderBy>;
  where?: InputMaybe<CompanyExtrasBoolExp>;
}>;

export type FetchManyCompanyExtraResponse = {
  __typename?: "query_root";
  company_extras: Array<{
    __typename?: "company_extras";
    body?: string | null;
    category: string;
    company_id?: any | null;
    created_at: any;
    found_count?: number | null;
    id: number;
    level: any;
    review?: any | null;
    success?: boolean | null;
    updated_at: any;
    url: string;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  }>;
};

export type CountCompanyExtraVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CompanyExtrasSelectColumn> | CompanyExtrasSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyExtrasOrderBy> | CompanyExtrasOrderBy>;
  where?: InputMaybe<CompanyExtrasBoolExp>;
}>;

export type CountCompanyExtraResponse = {
  __typename?: "query_root";
  company_extras_aggregate: {
    __typename?: "company_extras_aggregate";
    nodes: Array<{
      __typename?: "company_extras";
      body?: string | null;
      category: string;
      company_id?: any | null;
      created_at: any;
      found_count?: number | null;
      id: number;
      level: any;
      review?: any | null;
      success?: boolean | null;
      updated_at: any;
      url: string;
    }>;
  };
};

export type FetchOneCompanyExtraVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCompanyExtraResponse = {
  __typename?: "query_root";
  company_extras_by_pk?: {
    __typename?: "company_extras";
    body?: string | null;
    category: string;
    company_id?: any | null;
    created_at: any;
    found_count?: number | null;
    id: number;
    level: any;
    review?: any | null;
    success?: boolean | null;
    updated_at: any;
    url: string;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type FetchManyCompanyMetricVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CompanyMetricsSelectColumn> | CompanyMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyMetricsOrderBy> | CompanyMetricsOrderBy>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
}>;

export type FetchManyCompanyMetricResponse = {
  __typename?: "query_root";
  company_metrics: Array<{
    __typename?: "company_metrics";
    company_id: any;
    crawl_id: any;
    id: any;
    metric_id?: number | null;
    timestamp: any;
    value: any;
    metric_definition?: {
      __typename?: "metric_definitions";
      category?: string | null;
      description?: string | null;
      id: number;
      is_dimensional?: boolean | null;
      name: string;
      type: string;
      unit?: string | null;
    } | null;
  }>;
};

export type CountCompanyMetricVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CompanyMetricsSelectColumn> | CompanyMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CompanyMetricsOrderBy> | CompanyMetricsOrderBy>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
}>;

export type CountCompanyMetricResponse = {
  __typename?: "query_root";
  company_metrics_aggregate: {
    __typename?: "company_metrics_aggregate";
    nodes: Array<{
      __typename?: "company_metrics";
      company_id: any;
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
    }>;
  };
};

export type FetchOneCompanyMetricVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneCompanyMetricResponse = {
  __typename?: "query_root";
  company_metrics_by_pk?: {
    __typename?: "company_metrics";
    company_id: any;
    crawl_id: any;
    id: any;
    metric_id?: number | null;
    timestamp: any;
    value: any;
    metric_definition?: {
      __typename?: "metric_definitions";
      category?: string | null;
      description?: string | null;
      id: number;
      is_dimensional?: boolean | null;
      name: string;
      type: string;
      unit?: string | null;
    } | null;
  } | null;
};

export type FetchManyContactVariables = Exact<{
  distinct_on?: InputMaybe<Array<ContactsSelectColumn> | ContactsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContactsOrderBy> | ContactsOrderBy>;
  where?: InputMaybe<ContactsBoolExp>;
}>;

export type FetchManyContactResponse = {
  __typename?: "query_root";
  contacts: Array<{
    __typename?: "contacts";
    company_id?: any | null;
    contact_type?: any | null;
    created_at?: any | null;
    email?: string | null;
    id: number;
    is_primary?: boolean | null;
    phone?: string | null;
    privacy_level?: any | null;
    title?: string | null;
    updated_at?: any | null;
    user_id?: any | null;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    company_contacts: Array<{
      __typename?: "company_contacts";
      company_id?: any | null;
      contact_id: number;
      created_at: any;
      id: number;
      updated_at: any;
    }>;
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  }>;
};

export type CountContactVariables = Exact<{
  distinct_on?: InputMaybe<Array<ContactsSelectColumn> | ContactsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContactsOrderBy> | ContactsOrderBy>;
  where?: InputMaybe<ContactsBoolExp>;
}>;

export type CountContactResponse = {
  __typename?: "query_root";
  contacts_aggregate: {
    __typename?: "contacts_aggregate";
    nodes: Array<{
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
  };
};

export type FetchOneContactVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneContactResponse = {
  __typename?: "query_root";
  contacts_by_pk?: {
    __typename?: "contacts";
    company_id?: any | null;
    contact_type?: any | null;
    created_at?: any | null;
    email?: string | null;
    id: number;
    is_primary?: boolean | null;
    phone?: string | null;
    privacy_level?: any | null;
    title?: string | null;
    updated_at?: any | null;
    user_id?: any | null;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    company_contacts: Array<{
      __typename?: "company_contacts";
      company_id?: any | null;
      contact_id: number;
      created_at: any;
      id: number;
      updated_at: any;
    }>;
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type FetchManyContentCategoryVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ContentCategoriesSelectColumn> | ContentCategoriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<ContentCategoriesOrderBy> | ContentCategoriesOrderBy
  >;
  where?: InputMaybe<ContentCategoriesBoolExp>;
}>;

export type FetchManyContentCategoryResponse = {
  __typename?: "query_root";
  content_categories: Array<{
    __typename?: "content_categories";
    category_id: any;
    content_id: any;
    is_primary: boolean;
    category: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    };
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  }>;
};

export type CountContentCategoryVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ContentCategoriesSelectColumn> | ContentCategoriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<ContentCategoriesOrderBy> | ContentCategoriesOrderBy
  >;
  where?: InputMaybe<ContentCategoriesBoolExp>;
}>;

export type CountContentCategoryResponse = {
  __typename?: "query_root";
  content_categories_aggregate: {
    __typename?: "content_categories_aggregate";
    nodes: Array<{
      __typename?: "content_categories";
      category_id: any;
      content_id: any;
      is_primary: boolean;
    }>;
  };
};

export type FetchOneContentCategoryVariables = Exact<{
  category_id: Scalars["bigint"]["input"];
  content_id: Scalars["uuid"]["input"];
}>;

export type FetchOneContentCategoryResponse = {
  __typename?: "query_root";
  content_categories_by_pk?: {
    __typename?: "content_categories";
    category_id: any;
    content_id: any;
    is_primary: boolean;
    category: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    };
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type FetchManyContentScoreVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ContentScoresSelectColumn> | ContentScoresSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentScoresOrderBy> | ContentScoresOrderBy>;
  where?: InputMaybe<ContentScoresBoolExp>;
}>;

export type FetchManyContentScoreResponse = {
  __typename?: "query_root";
  content_scores: Array<{
    __typename?: "content_scores";
    categories?: any | null;
    content_type?: any | null;
    created_at?: any | null;
    hot_score?: any | null;
    id?: any | null;
    status?: any | null;
    tags?: any | null;
    title?: string | null;
    updated_at?: any | null;
    url?: string | null;
  }>;
};

export type CountContentScoreVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ContentScoresSelectColumn> | ContentScoresSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentScoresOrderBy> | ContentScoresOrderBy>;
  where?: InputMaybe<ContentScoresBoolExp>;
}>;

export type CountContentScoreResponse = {
  __typename?: "query_root";
  content_scores_aggregate: {
    __typename?: "content_scores_aggregate";
    nodes: Array<{
      __typename?: "content_scores";
      categories?: any | null;
      content_type?: any | null;
      created_at?: any | null;
      hot_score?: any | null;
      id?: any | null;
      status?: any | null;
      tags?: any | null;
      title?: string | null;
      updated_at?: any | null;
      url?: string | null;
    }>;
  };
};

export type FetchManyContentSourceVisitVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ContentSourceVisitsSelectColumn> | ContentSourceVisitsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<ContentSourceVisitsOrderBy> | ContentSourceVisitsOrderBy
  >;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
}>;

export type FetchManyContentSourceVisitResponse = {
  __typename?: "query_root";
  content_source_visits: Array<{
    __typename?: "content_source_visits";
    content_id: any;
    created_at?: any | null;
    id: any;
    user_id?: any | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  }>;
};

export type CountContentSourceVisitVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ContentSourceVisitsSelectColumn> | ContentSourceVisitsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<ContentSourceVisitsOrderBy> | ContentSourceVisitsOrderBy
  >;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
}>;

export type CountContentSourceVisitResponse = {
  __typename?: "query_root";
  content_source_visits_aggregate: {
    __typename?: "content_source_visits_aggregate";
    nodes: Array<{
      __typename?: "content_source_visits";
      content_id: any;
      created_at?: any | null;
      id: any;
      user_id?: any | null;
    }>;
  };
};

export type FetchOneContentSourceVisitVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneContentSourceVisitResponse = {
  __typename?: "query_root";
  content_source_visits_by_pk?: {
    __typename?: "content_source_visits";
    content_id: any;
    created_at?: any | null;
    id: any;
    user_id?: any | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type FetchManyContentSourceVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ContentSourcesSelectColumn> | ContentSourcesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourcesOrderBy> | ContentSourcesOrderBy>;
  where?: InputMaybe<ContentSourcesBoolExp>;
}>;

export type FetchManyContentSourceResponse = {
  __typename?: "query_root";
  content_sources: Array<{
    __typename?: "content_sources";
    company_id?: any | null;
    content_type: any;
    created_at?: any | null;
    expected_count?: any | null;
    failed_count?: any | null;
    has_failed?: boolean | null;
    hash?: any | null;
    id: any;
    priority: any;
    refreshed_at?: any | null;
    rss_urls?: Array<string> | null;
    scrape_frequency: any;
    scraped_at?: any | null;
    updated_at?: any | null;
    url: string;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    feed_sources: Array<{
      __typename?: "feed_sources";
      content_source_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    news: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
  }>;
};

export type CountContentSourceVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ContentSourcesSelectColumn> | ContentSourcesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentSourcesOrderBy> | ContentSourcesOrderBy>;
  where?: InputMaybe<ContentSourcesBoolExp>;
}>;

export type CountContentSourceResponse = {
  __typename?: "query_root";
  content_sources_aggregate: {
    __typename?: "content_sources_aggregate";
    nodes: Array<{
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
  };
};

export type FetchOneContentSourceVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneContentSourceResponse = {
  __typename?: "query_root";
  content_sources_by_pk?: {
    __typename?: "content_sources";
    company_id?: any | null;
    content_type: any;
    created_at?: any | null;
    expected_count?: any | null;
    failed_count?: any | null;
    has_failed?: boolean | null;
    hash?: any | null;
    id: any;
    priority: any;
    refreshed_at?: any | null;
    rss_urls?: Array<string> | null;
    scrape_frequency: any;
    scraped_at?: any | null;
    updated_at?: any | null;
    url: string;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    feed_sources: Array<{
      __typename?: "feed_sources";
      content_source_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    news: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
  } | null;
};

export type FetchManyContentStatusVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ContentStatusesSelectColumn> | ContentStatusesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentStatusesOrderBy> | ContentStatusesOrderBy>;
  where?: InputMaybe<ContentStatusesBoolExp>;
}>;

export type FetchManyContentStatusResponse = {
  __typename?: "query_root";
  content_statuses: Array<{
    __typename?: "content_statuses";
    content_id: any;
    content_status: any;
    created_at?: any | null;
    id: any;
    notes?: string | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  }>;
};

export type CountContentStatusVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ContentStatusesSelectColumn> | ContentStatusesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentStatusesOrderBy> | ContentStatusesOrderBy>;
  where?: InputMaybe<ContentStatusesBoolExp>;
}>;

export type CountContentStatusResponse = {
  __typename?: "query_root";
  content_statuses_aggregate: {
    __typename?: "content_statuses_aggregate";
    nodes: Array<{
      __typename?: "content_statuses";
      content_id: any;
      content_status: any;
      created_at?: any | null;
      id: any;
      notes?: string | null;
    }>;
  };
};

export type FetchOneContentStatusVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneContentStatusResponse = {
  __typename?: "query_root";
  content_statuses_by_pk?: {
    __typename?: "content_statuses";
    content_id: any;
    content_status: any;
    created_at?: any | null;
    id: any;
    notes?: string | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type FetchManyContentTagVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ContentTagsSelectColumn> | ContentTagsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentTagsOrderBy> | ContentTagsOrderBy>;
  where?: InputMaybe<ContentTagsBoolExp>;
}>;

export type FetchManyContentTagResponse = {
  __typename?: "query_root";
  content_tags: Array<{
    __typename?: "content_tags";
    content_id: any;
    tag_id: number;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    tag: {
      __typename?: "tags";
      body?: string | null;
      created_at?: any | null;
      document_id?: string | null;
      id: number;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    };
  }>;
};

export type CountContentTagVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ContentTagsSelectColumn> | ContentTagsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentTagsOrderBy> | ContentTagsOrderBy>;
  where?: InputMaybe<ContentTagsBoolExp>;
}>;

export type CountContentTagResponse = {
  __typename?: "query_root";
  content_tags_aggregate: {
    __typename?: "content_tags_aggregate";
    nodes: Array<{
      __typename?: "content_tags";
      content_id: any;
      tag_id: number;
    }>;
  };
};

export type FetchOneContentTagVariables = Exact<{
  content_id: Scalars["uuid"]["input"];
  tag_id: Scalars["Int"]["input"];
}>;

export type FetchOneContentTagResponse = {
  __typename?: "query_root";
  content_tags_by_pk?: {
    __typename?: "content_tags";
    content_id: any;
    tag_id: number;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    tag: {
      __typename?: "tags";
      body?: string | null;
      created_at?: any | null;
      document_id?: string | null;
      id: number;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    };
  } | null;
};

export type FetchManyContentVariables = Exact<{
  distinct_on?: InputMaybe<Array<ContentsSelectColumn> | ContentsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentsOrderBy> | ContentsOrderBy>;
  where?: InputMaybe<ContentsBoolExp>;
}>;

export type FetchManyContentResponse = {
  __typename?: "query_root";
  contents: Array<{
    __typename?: "contents";
    content_type: any;
    created_at?: any | null;
    hot_score?: any | null;
    id: any;
    rss_url?: string | null;
    title?: string | null;
    updated_at?: any | null;
    url: string;
    bookmarks: Array<{
      __typename?: "bookmarks";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      folder_id?: any | null;
      id: any;
      metadata?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    content_categories: Array<{
      __typename?: "content_categories";
      category_id: any;
      content_id: any;
      is_primary: boolean;
    }>;
    content_source_visits: Array<{
      __typename?: "content_source_visits";
      content_id: any;
      created_at?: any | null;
      id: any;
      user_id?: any | null;
    }>;
    content_statuses: Array<{
      __typename?: "content_statuses";
      content_id: any;
      content_status: any;
      created_at?: any | null;
      id: any;
      notes?: string | null;
    }>;
    content_tags: Array<{
      __typename?: "content_tags";
      content_id: any;
      tag_id: number;
    }>;
    news?: {
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    } | null;
    newsletter?: {
      __typename?: "newsletters";
      content_status: any;
      created_at?: any | null;
      end_date: any;
      frequency: string;
      generated_content?: string | null;
      id: any;
      start_date: any;
      title: string;
      updated_at?: any | null;
    } | null;
    research?: {
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
    } | null;
  }>;
};

export type CountContentVariables = Exact<{
  distinct_on?: InputMaybe<Array<ContentsSelectColumn> | ContentsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ContentsOrderBy> | ContentsOrderBy>;
  where?: InputMaybe<ContentsBoolExp>;
}>;

export type CountContentResponse = {
  __typename?: "query_root";
  contents_aggregate: {
    __typename?: "contents_aggregate";
    nodes: Array<{
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    }>;
  };
};

export type FetchOneContentVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneContentResponse = {
  __typename?: "query_root";
  contents_by_pk?: {
    __typename?: "contents";
    content_type: any;
    created_at?: any | null;
    hot_score?: any | null;
    id: any;
    rss_url?: string | null;
    title?: string | null;
    updated_at?: any | null;
    url: string;
    bookmarks: Array<{
      __typename?: "bookmarks";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      folder_id?: any | null;
      id: any;
      metadata?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    content_categories: Array<{
      __typename?: "content_categories";
      category_id: any;
      content_id: any;
      is_primary: boolean;
    }>;
    content_source_visits: Array<{
      __typename?: "content_source_visits";
      content_id: any;
      created_at?: any | null;
      id: any;
      user_id?: any | null;
    }>;
    content_statuses: Array<{
      __typename?: "content_statuses";
      content_id: any;
      content_status: any;
      created_at?: any | null;
      id: any;
      notes?: string | null;
    }>;
    content_tags: Array<{
      __typename?: "content_tags";
      content_id: any;
      tag_id: number;
    }>;
    news?: {
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    } | null;
    newsletter?: {
      __typename?: "newsletters";
      content_status: any;
      created_at?: any | null;
      end_date: any;
      frequency: string;
      generated_content?: string | null;
      id: any;
      start_date: any;
      title: string;
      updated_at?: any | null;
    } | null;
    research?: {
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
    } | null;
  } | null;
};

export type FetchManyCountryVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CountriesSelectColumn> | CountriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CountriesOrderBy> | CountriesOrderBy>;
  where?: InputMaybe<CountriesBoolExp>;
}>;

export type FetchManyCountryResponse = {
  __typename?: "query_root";
  countries: Array<{
    __typename?: "countries";
    code: string;
    code_3?: string | null;
    id: number;
    name: string;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    cities: Array<{
      __typename?: "cities";
      country_id: number;
      id: number;
      name: string;
      state?: string | null;
    }>;
  }>;
};

export type CountCountryVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CountriesSelectColumn> | CountriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CountriesOrderBy> | CountriesOrderBy>;
  where?: InputMaybe<CountriesBoolExp>;
}>;

export type CountCountryResponse = {
  __typename?: "query_root";
  countries_aggregate: {
    __typename?: "countries_aggregate";
    nodes: Array<{
      __typename?: "countries";
      code: string;
      code_3?: string | null;
      id: number;
      name: string;
    }>;
  };
};

export type FetchOneCountryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCountryResponse = {
  __typename?: "query_root";
  countries_by_pk?: {
    __typename?: "countries";
    code: string;
    code_3?: string | null;
    id: number;
    name: string;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    cities: Array<{
      __typename?: "cities";
      country_id: number;
      id: number;
      name: string;
      state?: string | null;
    }>;
  } | null;
};

export type FetchManyCustomerPaymentVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CustomerPaymentsSelectColumn> | CustomerPaymentsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<CustomerPaymentsOrderBy> | CustomerPaymentsOrderBy
  >;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
}>;

export type FetchManyCustomerPaymentResponse = {
  __typename?: "query_root";
  customer_payments: Array<{
    __typename?: "customer_payments";
    acquirer_data?: any | null;
    amount: any;
    amount_refunded?: any | null;
    amount_transferred?: any | null;
    bank?: string | null;
    captured?: boolean | null;
    created_at?: any | null;
    currency: string;
    description?: string | null;
    error_code?: string | null;
    error_description?: string | null;
    error_reason?: string | null;
    error_source?: string | null;
    error_step?: string | null;
    external_order_id?: string | null;
    external_payment_id: string;
    fee?: any | null;
    id: number;
    international?: boolean | null;
    invoice_id?: string | null;
    method?: string | null;
    notes?: any | null;
    order_id?: string | null;
    payment_provider_id: number;
    refund_status?: string | null;
    status: string;
    subscription_id?: number | null;
    tax?: any | null;
    user_id: any;
    vpa?: string | null;
    wallet?: string | null;
    customer_refunds: Array<{
      __typename?: "customer_refunds";
      acquirer_data?: any | null;
      amount: any;
      batch_id?: string | null;
      created_at?: any | null;
      currency?: string | null;
      external_refund_id: string;
      id: number;
      notes?: any | null;
      payment_id: number;
      receipt?: string | null;
      speed_processed?: string | null;
      speed_requested?: string | null;
      status: string;
    }>;
    customer_subscription?: {
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    } | null;
    payment_provider: {
      __typename?: "payment_providers";
      created_at?: any | null;
      id: number;
      is_active?: boolean | null;
      name: string;
      updated_at?: any | null;
    };
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  }>;
};

export type CountCustomerPaymentVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CustomerPaymentsSelectColumn> | CustomerPaymentsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<CustomerPaymentsOrderBy> | CustomerPaymentsOrderBy
  >;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
}>;

export type CountCustomerPaymentResponse = {
  __typename?: "query_root";
  customer_payments_aggregate: {
    __typename?: "customer_payments_aggregate";
    nodes: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
  };
};

export type FetchOneCustomerPaymentVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCustomerPaymentResponse = {
  __typename?: "query_root";
  customer_payments_by_pk?: {
    __typename?: "customer_payments";
    acquirer_data?: any | null;
    amount: any;
    amount_refunded?: any | null;
    amount_transferred?: any | null;
    bank?: string | null;
    captured?: boolean | null;
    created_at?: any | null;
    currency: string;
    description?: string | null;
    error_code?: string | null;
    error_description?: string | null;
    error_reason?: string | null;
    error_source?: string | null;
    error_step?: string | null;
    external_order_id?: string | null;
    external_payment_id: string;
    fee?: any | null;
    id: number;
    international?: boolean | null;
    invoice_id?: string | null;
    method?: string | null;
    notes?: any | null;
    order_id?: string | null;
    payment_provider_id: number;
    refund_status?: string | null;
    status: string;
    subscription_id?: number | null;
    tax?: any | null;
    user_id: any;
    vpa?: string | null;
    wallet?: string | null;
    customer_refunds: Array<{
      __typename?: "customer_refunds";
      acquirer_data?: any | null;
      amount: any;
      batch_id?: string | null;
      created_at?: any | null;
      currency?: string | null;
      external_refund_id: string;
      id: number;
      notes?: any | null;
      payment_id: number;
      receipt?: string | null;
      speed_processed?: string | null;
      speed_requested?: string | null;
      status: string;
    }>;
    customer_subscription?: {
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    } | null;
    payment_provider: {
      __typename?: "payment_providers";
      created_at?: any | null;
      id: number;
      is_active?: boolean | null;
      name: string;
      updated_at?: any | null;
    };
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type FetchManyCustomerProcessedWebhookVariables = Exact<{
  distinct_on?: InputMaybe<
    | Array<CustomerProcessedWebhooksSelectColumn>
    | CustomerProcessedWebhooksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<CustomerProcessedWebhooksOrderBy> | CustomerProcessedWebhooksOrderBy
  >;
  where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
}>;

export type FetchManyCustomerProcessedWebhookResponse = {
  __typename?: "query_root";
  customer_processed_webhooks: Array<{
    __typename?: "customer_processed_webhooks";
    event_id: string;
    event_type: string;
    id: number;
    processed_at: any;
  }>;
};

export type CountCustomerProcessedWebhookVariables = Exact<{
  distinct_on?: InputMaybe<
    | Array<CustomerProcessedWebhooksSelectColumn>
    | CustomerProcessedWebhooksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<CustomerProcessedWebhooksOrderBy> | CustomerProcessedWebhooksOrderBy
  >;
  where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
}>;

export type CountCustomerProcessedWebhookResponse = {
  __typename?: "query_root";
  customer_processed_webhooks_aggregate: {
    __typename?: "customer_processed_webhooks_aggregate";
    nodes: Array<{
      __typename?: "customer_processed_webhooks";
      event_id: string;
      event_type: string;
      id: number;
      processed_at: any;
    }>;
  };
};

export type FetchOneCustomerProcessedWebhookVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCustomerProcessedWebhookResponse = {
  __typename?: "query_root";
  customer_processed_webhooks_by_pk?: {
    __typename?: "customer_processed_webhooks";
    event_id: string;
    event_type: string;
    id: number;
    processed_at: any;
  } | null;
};

export type FetchManyCustomerRefundVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CustomerRefundsSelectColumn> | CustomerRefundsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerRefundsOrderBy> | CustomerRefundsOrderBy>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
}>;

export type FetchManyCustomerRefundResponse = {
  __typename?: "query_root";
  customer_refunds: Array<{
    __typename?: "customer_refunds";
    acquirer_data?: any | null;
    amount: any;
    batch_id?: string | null;
    created_at?: any | null;
    currency?: string | null;
    external_refund_id: string;
    id: number;
    notes?: any | null;
    payment_id: number;
    receipt?: string | null;
    speed_processed?: string | null;
    speed_requested?: string | null;
    status: string;
    customer_payment: {
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    };
  }>;
};

export type CountCustomerRefundVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CustomerRefundsSelectColumn> | CustomerRefundsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<CustomerRefundsOrderBy> | CustomerRefundsOrderBy>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
}>;

export type CountCustomerRefundResponse = {
  __typename?: "query_root";
  customer_refunds_aggregate: {
    __typename?: "customer_refunds_aggregate";
    nodes: Array<{
      __typename?: "customer_refunds";
      acquirer_data?: any | null;
      amount: any;
      batch_id?: string | null;
      created_at?: any | null;
      currency?: string | null;
      external_refund_id: string;
      id: number;
      notes?: any | null;
      payment_id: number;
      receipt?: string | null;
      speed_processed?: string | null;
      speed_requested?: string | null;
      status: string;
    }>;
  };
};

export type FetchOneCustomerRefundVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCustomerRefundResponse = {
  __typename?: "query_root";
  customer_refunds_by_pk?: {
    __typename?: "customer_refunds";
    acquirer_data?: any | null;
    amount: any;
    batch_id?: string | null;
    created_at?: any | null;
    currency?: string | null;
    external_refund_id: string;
    id: number;
    notes?: any | null;
    payment_id: number;
    receipt?: string | null;
    speed_processed?: string | null;
    speed_requested?: string | null;
    status: string;
    customer_payment: {
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    };
  } | null;
};

export type FetchManyCustomerSubscriptionPlanVariables = Exact<{
  distinct_on?: InputMaybe<
    | Array<CustomerSubscriptionPlansSelectColumn>
    | CustomerSubscriptionPlansSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<CustomerSubscriptionPlansOrderBy> | CustomerSubscriptionPlansOrderBy
  >;
  where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
}>;

export type FetchManyCustomerSubscriptionPlanResponse = {
  __typename?: "query_root";
  customer_subscription_plans: Array<{
    __typename?: "customer_subscription_plans";
    annual_amount: any;
    created_at?: any | null;
    currency: string;
    description?: string | null;
    external_plan_id?: string | null;
    features?: any | null;
    id: number;
    interval: number;
    interval_type: string;
    is_active?: boolean | null;
    monthly_amount: any;
    name: string;
    updated_at?: any | null;
    customer_subscriptions: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  }>;
};

export type CountCustomerSubscriptionPlanVariables = Exact<{
  distinct_on?: InputMaybe<
    | Array<CustomerSubscriptionPlansSelectColumn>
    | CustomerSubscriptionPlansSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<CustomerSubscriptionPlansOrderBy> | CustomerSubscriptionPlansOrderBy
  >;
  where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
}>;

export type CountCustomerSubscriptionPlanResponse = {
  __typename?: "query_root";
  customer_subscription_plans_aggregate: {
    __typename?: "customer_subscription_plans_aggregate";
    nodes: Array<{
      __typename?: "customer_subscription_plans";
      annual_amount: any;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      external_plan_id?: string | null;
      features?: any | null;
      id: number;
      interval: number;
      interval_type: string;
      is_active?: boolean | null;
      monthly_amount: any;
      name: string;
      updated_at?: any | null;
    }>;
  };
};

export type FetchOneCustomerSubscriptionPlanVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCustomerSubscriptionPlanResponse = {
  __typename?: "query_root";
  customer_subscription_plans_by_pk?: {
    __typename?: "customer_subscription_plans";
    annual_amount: any;
    created_at?: any | null;
    currency: string;
    description?: string | null;
    external_plan_id?: string | null;
    features?: any | null;
    id: number;
    interval: number;
    interval_type: string;
    is_active?: boolean | null;
    monthly_amount: any;
    name: string;
    updated_at?: any | null;
    customer_subscriptions: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  } | null;
};

export type FetchManyCustomerSubscriptionVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CustomerSubscriptionsSelectColumn> | CustomerSubscriptionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<CustomerSubscriptionsOrderBy> | CustomerSubscriptionsOrderBy
  >;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
}>;

export type FetchManyCustomerSubscriptionResponse = {
  __typename?: "query_root";
  customer_subscriptions: Array<{
    __typename?: "customer_subscriptions";
    auth_attempts?: number | null;
    cancel_at_period_end?: boolean | null;
    cancel_initiated_by?: string | null;
    change_scheduled_at?: any | null;
    charge_at?: any | null;
    created_at?: any | null;
    current_end: any;
    current_start: any;
    customer_notify?: boolean | null;
    end_at?: any | null;
    ended_at?: any | null;
    expire_by?: any | null;
    external_subscription_id: string;
    has_scheduled_changes?: boolean | null;
    id: number;
    notes?: any | null;
    offer_id?: string | null;
    paid_count?: number | null;
    pause_initiated_by?: string | null;
    payment_provider_id: number;
    plan_id: number;
    quantity?: number | null;
    remaining_count?: number | null;
    short_url?: string | null;
    source?: string | null;
    start_at?: any | null;
    status: string;
    total_count?: number | null;
    type?: number | null;
    updated_at?: any | null;
    user_id: any;
    customer_payments: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
    customer_subscription_plan: {
      __typename?: "customer_subscription_plans";
      annual_amount: any;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      external_plan_id?: string | null;
      features?: any | null;
      id: number;
      interval: number;
      interval_type: string;
      is_active?: boolean | null;
      monthly_amount: any;
      name: string;
      updated_at?: any | null;
    };
    payment_provider: {
      __typename?: "payment_providers";
      created_at?: any | null;
      id: number;
      is_active?: boolean | null;
      name: string;
      updated_at?: any | null;
    };
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  }>;
};

export type CountCustomerSubscriptionVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<CustomerSubscriptionsSelectColumn> | CustomerSubscriptionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<CustomerSubscriptionsOrderBy> | CustomerSubscriptionsOrderBy
  >;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
}>;

export type CountCustomerSubscriptionResponse = {
  __typename?: "query_root";
  customer_subscriptions_aggregate: {
    __typename?: "customer_subscriptions_aggregate";
    nodes: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  };
};

export type FetchOneCustomerSubscriptionVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCustomerSubscriptionResponse = {
  __typename?: "query_root";
  customer_subscriptions_by_pk?: {
    __typename?: "customer_subscriptions";
    auth_attempts?: number | null;
    cancel_at_period_end?: boolean | null;
    cancel_initiated_by?: string | null;
    change_scheduled_at?: any | null;
    charge_at?: any | null;
    created_at?: any | null;
    current_end: any;
    current_start: any;
    customer_notify?: boolean | null;
    end_at?: any | null;
    ended_at?: any | null;
    expire_by?: any | null;
    external_subscription_id: string;
    has_scheduled_changes?: boolean | null;
    id: number;
    notes?: any | null;
    offer_id?: string | null;
    paid_count?: number | null;
    pause_initiated_by?: string | null;
    payment_provider_id: number;
    plan_id: number;
    quantity?: number | null;
    remaining_count?: number | null;
    short_url?: string | null;
    source?: string | null;
    start_at?: any | null;
    status: string;
    total_count?: number | null;
    type?: number | null;
    updated_at?: any | null;
    user_id: any;
    customer_payments: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
    customer_subscription_plan: {
      __typename?: "customer_subscription_plans";
      annual_amount: any;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      external_plan_id?: string | null;
      features?: any | null;
      id: number;
      interval: number;
      interval_type: string;
      is_active?: boolean | null;
      monthly_amount: any;
      name: string;
      updated_at?: any | null;
    };
    payment_provider: {
      __typename?: "payment_providers";
      created_at?: any | null;
      id: number;
      is_active?: boolean | null;
      name: string;
      updated_at?: any | null;
    };
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type FetchManyEmbeddingReviewVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<EmbeddingReviewsSelectColumn> | EmbeddingReviewsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<EmbeddingReviewsOrderBy> | EmbeddingReviewsOrderBy
  >;
  where?: InputMaybe<EmbeddingReviewsBoolExp>;
}>;

export type FetchManyEmbeddingReviewResponse = {
  __typename?: "query_root";
  embedding_reviews: Array<{
    __typename?: "embedding_reviews";
    agent_review?: boolean | null;
    created_at: any;
    human_review?: boolean | null;
    id: any;
    notes?: string | null;
    updated_at?: any | null;
    research_embeddings: Array<{
      __typename?: "research_embeddings";
      chunk: string;
      created_at?: any | null;
      embedding?: any | null;
      embedding_review_id?: any | null;
      id: number;
      is_flagged?: boolean | null;
      research_id: any;
      updated_at: any;
      url?: string | null;
    }>;
  }>;
};

export type CountEmbeddingReviewVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<EmbeddingReviewsSelectColumn> | EmbeddingReviewsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<EmbeddingReviewsOrderBy> | EmbeddingReviewsOrderBy
  >;
  where?: InputMaybe<EmbeddingReviewsBoolExp>;
}>;

export type CountEmbeddingReviewResponse = {
  __typename?: "query_root";
  embedding_reviews_aggregate: {
    __typename?: "embedding_reviews_aggregate";
    nodes: Array<{
      __typename?: "embedding_reviews";
      agent_review?: boolean | null;
      created_at: any;
      human_review?: boolean | null;
      id: any;
      notes?: string | null;
      updated_at?: any | null;
    }>;
  };
};

export type FetchOneEmbeddingReviewVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneEmbeddingReviewResponse = {
  __typename?: "query_root";
  embedding_reviews_by_pk?: {
    __typename?: "embedding_reviews";
    agent_review?: boolean | null;
    created_at: any;
    human_review?: boolean | null;
    id: any;
    notes?: string | null;
    updated_at?: any | null;
    research_embeddings: Array<{
      __typename?: "research_embeddings";
      chunk: string;
      created_at?: any | null;
      embedding?: any | null;
      embedding_review_id?: any | null;
      id: number;
      is_flagged?: boolean | null;
      research_id: any;
      updated_at: any;
      url?: string | null;
    }>;
  } | null;
};

export type FetchManyErrorCorrelationVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ErrorCorrelationsSelectColumn> | ErrorCorrelationsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<ErrorCorrelationsOrderBy> | ErrorCorrelationsOrderBy
  >;
  where?: InputMaybe<ErrorCorrelationsBoolExp>;
}>;

export type FetchManyErrorCorrelationResponse = {
  __typename?: "query_root";
  error_correlations: Array<{
    __typename?: "error_correlations";
    avg_time_difference?: any | null;
    correlation_count?: any | null;
    id?: any | null;
    source_pattern?: string | null;
    source_service?: string | null;
    target_pattern?: string | null;
    target_service?: string | null;
  }>;
};

export type CountErrorCorrelationVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ErrorCorrelationsSelectColumn> | ErrorCorrelationsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<ErrorCorrelationsOrderBy> | ErrorCorrelationsOrderBy
  >;
  where?: InputMaybe<ErrorCorrelationsBoolExp>;
}>;

export type CountErrorCorrelationResponse = {
  __typename?: "query_root";
  error_correlations_aggregate: {
    __typename?: "error_correlations_aggregate";
    nodes: Array<{
      __typename?: "error_correlations";
      avg_time_difference?: any | null;
      correlation_count?: any | null;
      id?: any | null;
      source_pattern?: string | null;
      source_service?: string | null;
      target_pattern?: string | null;
      target_service?: string | null;
    }>;
  };
};

export type FetchManyErrorFrequencyVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ErrorFrequencySelectColumn> | ErrorFrequencySelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorFrequencyOrderBy> | ErrorFrequencyOrderBy>;
  where?: InputMaybe<ErrorFrequencyBoolExp>;
}>;

export type FetchManyErrorFrequencyResponse = {
  __typename?: "query_root";
  error_frequency: Array<{
    __typename?: "error_frequency";
    error_count?: any | null;
    error_type?: any | null;
    service_name?: string | null;
    severity?: any | null;
    time_bucket?: any | null;
  }>;
};

export type CountErrorFrequencyVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ErrorFrequencySelectColumn> | ErrorFrequencySelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorFrequencyOrderBy> | ErrorFrequencyOrderBy>;
  where?: InputMaybe<ErrorFrequencyBoolExp>;
}>;

export type CountErrorFrequencyResponse = {
  __typename?: "query_root";
  error_frequency_aggregate: {
    __typename?: "error_frequency_aggregate";
    nodes: Array<{
      __typename?: "error_frequency";
      error_count?: any | null;
      error_type?: any | null;
      service_name?: string | null;
      severity?: any | null;
      time_bucket?: any | null;
    }>;
  };
};

export type FetchManyErrorLogVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ErrorLogsSelectColumn> | ErrorLogsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorLogsOrderBy> | ErrorLogsOrderBy>;
  where?: InputMaybe<ErrorLogsBoolExp>;
}>;

export type FetchManyErrorLogResponse = {
  __typename?: "query_root";
  error_logs: Array<{
    __typename?: "error_logs";
    context?: any | null;
    correlation_id?: any | null;
    created_at?: any | null;
    domain?: string | null;
    environment: string;
    error_hash?: string | null;
    error_pattern?: string | null;
    error_type: any;
    frequency_data?: any | null;
    github_repo?: string | null;
    id: any;
    is_new_pattern?: boolean | null;
    message: string;
    metadata?: any | null;
    related_errors?: any | null;
    request_id?: any | null;
    service_name: string;
    severity: any;
    stack_trace?: string | null;
    user_id?: any | null;
  }>;
};

export type CountErrorLogVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ErrorLogsSelectColumn> | ErrorLogsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorLogsOrderBy> | ErrorLogsOrderBy>;
  where?: InputMaybe<ErrorLogsBoolExp>;
}>;

export type CountErrorLogResponse = {
  __typename?: "query_root";
  error_logs_aggregate: {
    __typename?: "error_logs_aggregate";
    nodes: Array<{
      __typename?: "error_logs";
      context?: any | null;
      correlation_id?: any | null;
      created_at?: any | null;
      domain?: string | null;
      environment: string;
      error_hash?: string | null;
      error_pattern?: string | null;
      error_type: any;
      frequency_data?: any | null;
      github_repo?: string | null;
      id: any;
      is_new_pattern?: boolean | null;
      message: string;
      metadata?: any | null;
      related_errors?: any | null;
      request_id?: any | null;
      service_name: string;
      severity: any;
      stack_trace?: string | null;
      user_id?: any | null;
    }>;
  };
};

export type FetchOneErrorLogVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneErrorLogResponse = {
  __typename?: "query_root";
  error_logs_by_pk?: {
    __typename?: "error_logs";
    context?: any | null;
    correlation_id?: any | null;
    created_at?: any | null;
    domain?: string | null;
    environment: string;
    error_hash?: string | null;
    error_pattern?: string | null;
    error_type: any;
    frequency_data?: any | null;
    github_repo?: string | null;
    id: any;
    is_new_pattern?: boolean | null;
    message: string;
    metadata?: any | null;
    related_errors?: any | null;
    request_id?: any | null;
    service_name: string;
    severity: any;
    stack_trace?: string | null;
    user_id?: any | null;
  } | null;
};

export type FetchManyErrorMetricVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ErrorMetricsSelectColumn> | ErrorMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorMetricsOrderBy> | ErrorMetricsOrderBy>;
  where?: InputMaybe<ErrorMetricsBoolExp>;
}>;

export type FetchManyErrorMetricResponse = {
  __typename?: "query_root";
  error_metrics: Array<{
    __typename?: "error_metrics";
    error_count?: any | null;
    error_type?: any | null;
    service_name?: string | null;
    severity?: any | null;
    time_bucket?: any | null;
  }>;
};

export type CountErrorMetricVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ErrorMetricsSelectColumn> | ErrorMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorMetricsOrderBy> | ErrorMetricsOrderBy>;
  where?: InputMaybe<ErrorMetricsBoolExp>;
}>;

export type CountErrorMetricResponse = {
  __typename?: "query_root";
  error_metrics_aggregate: {
    __typename?: "error_metrics_aggregate";
    nodes: Array<{
      __typename?: "error_metrics";
      error_count?: any | null;
      error_type?: any | null;
      service_name?: string | null;
      severity?: any | null;
      time_bucket?: any | null;
    }>;
  };
};

export type FetchManyErrorPatternVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ErrorPatternsSelectColumn> | ErrorPatternsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorPatternsOrderBy> | ErrorPatternsOrderBy>;
  where?: InputMaybe<ErrorPatternsBoolExp>;
}>;

export type FetchManyErrorPatternResponse = {
  __typename?: "query_root";
  error_patterns: Array<{
    __typename?: "error_patterns";
    contexts?: any | null;
    daily_frequency?: any | null;
    days_active?: any | null;
    error_hash?: string | null;
    error_pattern?: string | null;
    first_seen?: any | null;
    id?: any | null;
    is_new?: boolean | null;
    last_seen?: any | null;
    occurrence_count?: any | null;
    service_name?: string | null;
    severity_levels?: Array<any> | null;
  }>;
};

export type CountErrorPatternVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ErrorPatternsSelectColumn> | ErrorPatternsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorPatternsOrderBy> | ErrorPatternsOrderBy>;
  where?: InputMaybe<ErrorPatternsBoolExp>;
}>;

export type CountErrorPatternResponse = {
  __typename?: "query_root";
  error_patterns_aggregate: {
    __typename?: "error_patterns_aggregate";
    nodes: Array<{
      __typename?: "error_patterns";
      contexts?: any | null;
      daily_frequency?: any | null;
      days_active?: any | null;
      error_hash?: string | null;
      error_pattern?: string | null;
      first_seen?: any | null;
      id?: any | null;
      is_new?: boolean | null;
      last_seen?: any | null;
      occurrence_count?: any | null;
      service_name?: string | null;
      severity_levels?: Array<any> | null;
    }>;
  };
};

export type FetchManyErrorStatVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ErrorStatsSelectColumn> | ErrorStatsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorStatsOrderBy> | ErrorStatsOrderBy>;
  where?: InputMaybe<ErrorStatsBoolExp>;
}>;

export type FetchManyErrorStatResponse = {
  __typename?: "query_root";
  error_stats: Array<{
    __typename?: "error_stats";
    calls?: any | null;
    max_exec_time?: any | null;
    mean_exec_time?: any | null;
    query?: string | null;
    queryid?: any | null;
    rows?: any | null;
    toplevel?: boolean | null;
  }>;
};

export type CountErrorStatVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ErrorStatsSelectColumn> | ErrorStatsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ErrorStatsOrderBy> | ErrorStatsOrderBy>;
  where?: InputMaybe<ErrorStatsBoolExp>;
}>;

export type CountErrorStatResponse = {
  __typename?: "query_root";
  error_stats_aggregate: {
    __typename?: "error_stats_aggregate";
    nodes: Array<{
      __typename?: "error_stats";
      calls?: any | null;
      max_exec_time?: any | null;
      mean_exec_time?: any | null;
      query?: string | null;
      queryid?: any | null;
      rows?: any | null;
      toplevel?: boolean | null;
    }>;
  };
};

export type FetchManyFeatureRequestVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<FeatureRequestsSelectColumn> | FeatureRequestsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeatureRequestsOrderBy> | FeatureRequestsOrderBy>;
  where?: InputMaybe<FeatureRequestsBoolExp>;
}>;

export type FetchManyFeatureRequestResponse = {
  __typename?: "query_root";
  feature_requests: Array<{
    __typename?: "feature_requests";
    created_at?: any | null;
    description?: string | null;
    downvotes?: number | null;
    engagement_score?: number | null;
    id: any;
    priority_score?: number | null;
    status: string;
    title: string;
    updated_at?: any | null;
    upvotes?: number | null;
    feature_votes: Array<{
      __typename?: "feature_votes";
      created_at?: any | null;
      feature_id: any;
      feedback?: string | null;
      id: any;
      updated_at?: any | null;
      user_id: any;
      vote_type: any;
    }>;
  }>;
};

export type CountFeatureRequestVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<FeatureRequestsSelectColumn> | FeatureRequestsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeatureRequestsOrderBy> | FeatureRequestsOrderBy>;
  where?: InputMaybe<FeatureRequestsBoolExp>;
}>;

export type CountFeatureRequestResponse = {
  __typename?: "query_root";
  feature_requests_aggregate: {
    __typename?: "feature_requests_aggregate";
    nodes: Array<{
      __typename?: "feature_requests";
      created_at?: any | null;
      description?: string | null;
      downvotes?: number | null;
      engagement_score?: number | null;
      id: any;
      priority_score?: number | null;
      status: string;
      title: string;
      updated_at?: any | null;
      upvotes?: number | null;
    }>;
  };
};

export type FetchOneFeatureRequestVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneFeatureRequestResponse = {
  __typename?: "query_root";
  feature_requests_by_pk?: {
    __typename?: "feature_requests";
    created_at?: any | null;
    description?: string | null;
    downvotes?: number | null;
    engagement_score?: number | null;
    id: any;
    priority_score?: number | null;
    status: string;
    title: string;
    updated_at?: any | null;
    upvotes?: number | null;
    feature_votes: Array<{
      __typename?: "feature_votes";
      created_at?: any | null;
      feature_id: any;
      feedback?: string | null;
      id: any;
      updated_at?: any | null;
      user_id: any;
      vote_type: any;
    }>;
  } | null;
};

export type FetchManyFeatureVoteVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<FeatureVotesSelectColumn> | FeatureVotesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeatureVotesOrderBy> | FeatureVotesOrderBy>;
  where?: InputMaybe<FeatureVotesBoolExp>;
}>;

export type FetchManyFeatureVoteResponse = {
  __typename?: "query_root";
  feature_votes: Array<{
    __typename?: "feature_votes";
    created_at?: any | null;
    feature_id: any;
    feedback?: string | null;
    id: any;
    updated_at?: any | null;
    user_id: any;
    vote_type: any;
    feature_request: {
      __typename?: "feature_requests";
      created_at?: any | null;
      description?: string | null;
      downvotes?: number | null;
      engagement_score?: number | null;
      id: any;
      priority_score?: number | null;
      status: string;
      title: string;
      updated_at?: any | null;
      upvotes?: number | null;
    };
  }>;
};

export type CountFeatureVoteVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<FeatureVotesSelectColumn> | FeatureVotesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeatureVotesOrderBy> | FeatureVotesOrderBy>;
  where?: InputMaybe<FeatureVotesBoolExp>;
}>;

export type CountFeatureVoteResponse = {
  __typename?: "query_root";
  feature_votes_aggregate: {
    __typename?: "feature_votes_aggregate";
    nodes: Array<{
      __typename?: "feature_votes";
      created_at?: any | null;
      feature_id: any;
      feedback?: string | null;
      id: any;
      updated_at?: any | null;
      user_id: any;
      vote_type: any;
    }>;
  };
};

export type FetchOneFeatureVoteVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneFeatureVoteResponse = {
  __typename?: "query_root";
  feature_votes_by_pk?: {
    __typename?: "feature_votes";
    created_at?: any | null;
    feature_id: any;
    feedback?: string | null;
    id: any;
    updated_at?: any | null;
    user_id: any;
    vote_type: any;
    feature_request: {
      __typename?: "feature_requests";
      created_at?: any | null;
      description?: string | null;
      downvotes?: number | null;
      engagement_score?: number | null;
      id: any;
      priority_score?: number | null;
      status: string;
      title: string;
      updated_at?: any | null;
      upvotes?: number | null;
    };
  } | null;
};

export type FetchManyFeedCategoryVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<FeedCategoriesSelectColumn> | FeedCategoriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedCategoriesOrderBy> | FeedCategoriesOrderBy>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
}>;

export type FetchManyFeedCategoryResponse = {
  __typename?: "query_root";
  feed_categories: Array<{
    __typename?: "feed_categories";
    category_id?: any | null;
    created_at: any;
    feed_id?: any | null;
    id: any;
    category?: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    } | null;
    feed?: {
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    } | null;
  }>;
};

export type CountFeedCategoryVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<FeedCategoriesSelectColumn> | FeedCategoriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedCategoriesOrderBy> | FeedCategoriesOrderBy>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
}>;

export type CountFeedCategoryResponse = {
  __typename?: "query_root";
  feed_categories_aggregate: {
    __typename?: "feed_categories_aggregate";
    nodes: Array<{
      __typename?: "feed_categories";
      category_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
  };
};

export type FetchOneFeedCategoryVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneFeedCategoryResponse = {
  __typename?: "query_root";
  feed_categories_by_pk?: {
    __typename?: "feed_categories";
    category_id?: any | null;
    created_at: any;
    feed_id?: any | null;
    id: any;
    category?: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    } | null;
    feed?: {
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    } | null;
  } | null;
};

export type FetchManyFeedSourceVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<FeedSourcesSelectColumn> | FeedSourcesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedSourcesOrderBy> | FeedSourcesOrderBy>;
  where?: InputMaybe<FeedSourcesBoolExp>;
}>;

export type FetchManyFeedSourceResponse = {
  __typename?: "query_root";
  feed_sources: Array<{
    __typename?: "feed_sources";
    content_source_id?: any | null;
    created_at: any;
    feed_id?: any | null;
    id: any;
    content_source?: {
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    } | null;
    feed?: {
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    } | null;
  }>;
};

export type CountFeedSourceVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<FeedSourcesSelectColumn> | FeedSourcesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedSourcesOrderBy> | FeedSourcesOrderBy>;
  where?: InputMaybe<FeedSourcesBoolExp>;
}>;

export type CountFeedSourceResponse = {
  __typename?: "query_root";
  feed_sources_aggregate: {
    __typename?: "feed_sources_aggregate";
    nodes: Array<{
      __typename?: "feed_sources";
      content_source_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
  };
};

export type FetchOneFeedSourceVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneFeedSourceResponse = {
  __typename?: "query_root";
  feed_sources_by_pk?: {
    __typename?: "feed_sources";
    content_source_id?: any | null;
    created_at: any;
    feed_id?: any | null;
    id: any;
    content_source?: {
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    } | null;
    feed?: {
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    } | null;
  } | null;
};

export type FetchManyFeedbackVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<FeedbacksSelectColumn> | FeedbacksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedbacksOrderBy> | FeedbacksOrderBy>;
  where?: InputMaybe<FeedbacksBoolExp>;
}>;

export type FetchManyFeedbackResponse = {
  __typename?: "query_root";
  feedbacks: Array<{
    __typename?: "feedbacks";
    created_at: any;
    device_info?: string | null;
    feedback_status?: any | null;
    feedback_type?: any | null;
    id: number;
    message: string;
    page_identifier: string;
    rating?: number | null;
    resolution_comment?: string | null;
    updated_at: any;
    user_id?: any | null;
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  }>;
};

export type CountFeedbackVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<FeedbacksSelectColumn> | FeedbacksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedbacksOrderBy> | FeedbacksOrderBy>;
  where?: InputMaybe<FeedbacksBoolExp>;
}>;

export type CountFeedbackResponse = {
  __typename?: "query_root";
  feedbacks_aggregate: {
    __typename?: "feedbacks_aggregate";
    nodes: Array<{
      __typename?: "feedbacks";
      created_at: any;
      device_info?: string | null;
      feedback_status?: any | null;
      feedback_type?: any | null;
      id: number;
      message: string;
      page_identifier: string;
      rating?: number | null;
      resolution_comment?: string | null;
      updated_at: any;
      user_id?: any | null;
    }>;
  };
};

export type FetchOneFeedbackVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneFeedbackResponse = {
  __typename?: "query_root";
  feedbacks_by_pk?: {
    __typename?: "feedbacks";
    created_at: any;
    device_info?: string | null;
    feedback_status?: any | null;
    feedback_type?: any | null;
    id: number;
    message: string;
    page_identifier: string;
    rating?: number | null;
    resolution_comment?: string | null;
    updated_at: any;
    user_id?: any | null;
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type FetchManyFeedVariables = Exact<{
  distinct_on?: InputMaybe<Array<FeedsSelectColumn> | FeedsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedsOrderBy> | FeedsOrderBy>;
  where?: InputMaybe<FeedsBoolExp>;
}>;

export type FetchManyFeedResponse = {
  __typename?: "query_root";
  feeds: Array<{
    __typename?: "feeds";
    created_at: any;
    id: any;
    name?: string | null;
    user_id?: any | null;
    feed_categories: Array<{
      __typename?: "feed_categories";
      category_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    feed_sources: Array<{
      __typename?: "feed_sources";
      content_source_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  }>;
};

export type CountFeedVariables = Exact<{
  distinct_on?: InputMaybe<Array<FeedsSelectColumn> | FeedsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FeedsOrderBy> | FeedsOrderBy>;
  where?: InputMaybe<FeedsBoolExp>;
}>;

export type CountFeedResponse = {
  __typename?: "query_root";
  feeds_aggregate: {
    __typename?: "feeds_aggregate";
    nodes: Array<{
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    }>;
  };
};

export type FetchOneFeedVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneFeedResponse = {
  __typename?: "query_root";
  feeds_by_pk?: {
    __typename?: "feeds";
    created_at: any;
    id: any;
    name?: string | null;
    user_id?: any | null;
    feed_categories: Array<{
      __typename?: "feed_categories";
      category_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    feed_sources: Array<{
      __typename?: "feed_sources";
      content_source_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type FetchManyFollowVariables = Exact<{
  distinct_on?: InputMaybe<Array<FollowsSelectColumn> | FollowsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FollowsOrderBy> | FollowsOrderBy>;
  where?: InputMaybe<FollowsBoolExp>;
}>;

export type FetchManyFollowResponse = {
  __typename?: "query_root";
  follows: Array<{
    __typename?: "follows";
    created_at?: any | null;
    followed_entity: any;
    followed_id: any;
    id: any;
    user_id: any;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  }>;
};

export type CountFollowVariables = Exact<{
  distinct_on?: InputMaybe<Array<FollowsSelectColumn> | FollowsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<FollowsOrderBy> | FollowsOrderBy>;
  where?: InputMaybe<FollowsBoolExp>;
}>;

export type CountFollowResponse = {
  __typename?: "query_root";
  follows_aggregate: {
    __typename?: "follows_aggregate";
    nodes: Array<{
      __typename?: "follows";
      created_at?: any | null;
      followed_entity: any;
      followed_id: any;
      id: any;
      user_id: any;
    }>;
  };
};

export type FetchOneFollowVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneFollowResponse = {
  __typename?: "query_root";
  follows_by_pk?: {
    __typename?: "follows";
    created_at?: any | null;
    followed_entity: any;
    followed_id: any;
    id: any;
    user_id: any;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type FetchManyMetricDefinitionVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<MetricDefinitionsSelectColumn> | MetricDefinitionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<MetricDefinitionsOrderBy> | MetricDefinitionsOrderBy
  >;
  where?: InputMaybe<MetricDefinitionsBoolExp>;
}>;

export type FetchManyMetricDefinitionResponse = {
  __typename?: "query_root";
  metric_definitions: Array<{
    __typename?: "metric_definitions";
    category?: string | null;
    description?: string | null;
    id: number;
    is_dimensional?: boolean | null;
    name: string;
    type: string;
    unit?: string | null;
    company_metrics: Array<{
      __typename?: "company_metrics";
      company_id: any;
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
    }>;
    spider_metrics: Array<{
      __typename?: "spider_metrics";
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
    }>;
  }>;
};

export type CountMetricDefinitionVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<MetricDefinitionsSelectColumn> | MetricDefinitionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<MetricDefinitionsOrderBy> | MetricDefinitionsOrderBy
  >;
  where?: InputMaybe<MetricDefinitionsBoolExp>;
}>;

export type CountMetricDefinitionResponse = {
  __typename?: "query_root";
  metric_definitions_aggregate: {
    __typename?: "metric_definitions_aggregate";
    nodes: Array<{
      __typename?: "metric_definitions";
      category?: string | null;
      description?: string | null;
      id: number;
      is_dimensional?: boolean | null;
      name: string;
      type: string;
      unit?: string | null;
    }>;
  };
};

export type FetchOneMetricDefinitionVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneMetricDefinitionResponse = {
  __typename?: "query_root";
  metric_definitions_by_pk?: {
    __typename?: "metric_definitions";
    category?: string | null;
    description?: string | null;
    id: number;
    is_dimensional?: boolean | null;
    name: string;
    type: string;
    unit?: string | null;
    company_metrics: Array<{
      __typename?: "company_metrics";
      company_id: any;
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
    }>;
    spider_metrics: Array<{
      __typename?: "spider_metrics";
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
    }>;
  } | null;
};

export type FetchManyNewsVariables = Exact<{
  distinct_on?: InputMaybe<Array<NewsSelectColumn> | NewsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsOrderBy> | NewsOrderBy>;
  where?: InputMaybe<NewsBoolExp>;
}>;

export type FetchManyNewsResponse = {
  __typename?: "query_root";
  news: Array<{
    __typename?: "news";
    author?: string | null;
    body?: string | null;
    category_id?: any | null;
    company_id?: any | null;
    content_source_id?: any | null;
    content_status: any;
    created_at: any;
    description?: string | null;
    failed_count?: any | null;
    featured_image?: string | null;
    has_summary: boolean;
    hash?: any | null;
    id: any;
    keywords?: any | null;
    published_at?: any | null;
    scrape_frequency: any;
    scraped_at?: any | null;
    title?: string | null;
    updated_at: any;
    url: string;
    category?: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    } | null;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    content_source?: {
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    } | null;
    news_summaries: Array<{
      __typename?: "news_summaries";
      complexity_level?: any | null;
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      is_current?: boolean | null;
      news_id: any;
      summary?: string | null;
      updated_at?: any | null;
      version: number;
    }>;
  }>;
};

export type CountNewsVariables = Exact<{
  distinct_on?: InputMaybe<Array<NewsSelectColumn> | NewsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsOrderBy> | NewsOrderBy>;
  where?: InputMaybe<NewsBoolExp>;
}>;

export type CountNewsResponse = {
  __typename?: "query_root";
  news_aggregate: {
    __typename?: "news_aggregate";
    nodes: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
  };
};

export type FetchOneNewsVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneNewsResponse = {
  __typename?: "query_root";
  news_by_pk?: {
    __typename?: "news";
    author?: string | null;
    body?: string | null;
    category_id?: any | null;
    company_id?: any | null;
    content_source_id?: any | null;
    content_status: any;
    created_at: any;
    description?: string | null;
    failed_count?: any | null;
    featured_image?: string | null;
    has_summary: boolean;
    hash?: any | null;
    id: any;
    keywords?: any | null;
    published_at?: any | null;
    scrape_frequency: any;
    scraped_at?: any | null;
    title?: string | null;
    updated_at: any;
    url: string;
    category?: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    } | null;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    content_source?: {
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    } | null;
    news_summaries: Array<{
      __typename?: "news_summaries";
      complexity_level?: any | null;
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      is_current?: boolean | null;
      news_id: any;
      summary?: string | null;
      updated_at?: any | null;
      version: number;
    }>;
  } | null;
};

export type FetchManyNewsDetailVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<NewsDetailsSelectColumn> | NewsDetailsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsDetailsOrderBy> | NewsDetailsOrderBy>;
  where?: InputMaybe<NewsDetailsBoolExp>;
}>;

export type FetchManyNewsDetailResponse = {
  __typename?: "query_root";
  news_details: Array<{
    __typename?: "news_details";
    author?: string | null;
    bookmark_count?: any | null;
    categories?: any | null;
    company_logo?: string | null;
    company_name?: string | null;
    created_at?: any | null;
    description?: string | null;
    featured_image?: string | null;
    hot_score?: any | null;
    id?: any | null;
    published_at?: any | null;
    summaries?: any | null;
    tags?: any | null;
    title?: string | null;
    updated_at?: any | null;
    url?: string | null;
    vote_count?: any | null;
  }>;
};

export type CountNewsDetailVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<NewsDetailsSelectColumn> | NewsDetailsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsDetailsOrderBy> | NewsDetailsOrderBy>;
  where?: InputMaybe<NewsDetailsBoolExp>;
}>;

export type CountNewsDetailResponse = {
  __typename?: "query_root";
  news_details_aggregate: {
    __typename?: "news_details_aggregate";
    nodes: Array<{
      __typename?: "news_details";
      author?: string | null;
      bookmark_count?: any | null;
      categories?: any | null;
      company_logo?: string | null;
      company_name?: string | null;
      created_at?: any | null;
      description?: string | null;
      featured_image?: string | null;
      hot_score?: any | null;
      id?: any | null;
      published_at?: any | null;
      summaries?: any | null;
      tags?: any | null;
      title?: string | null;
      updated_at?: any | null;
      url?: string | null;
      vote_count?: any | null;
    }>;
  };
};

export type FetchManyNewsSummaryVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<NewsSummariesSelectColumn> | NewsSummariesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsSummariesOrderBy> | NewsSummariesOrderBy>;
  where?: InputMaybe<NewsSummariesBoolExp>;
}>;

export type FetchManyNewsSummaryResponse = {
  __typename?: "query_root";
  news_summaries: Array<{
    __typename?: "news_summaries";
    complexity_level?: any | null;
    created_at?: any | null;
    embedding?: any | null;
    id: any;
    is_current?: boolean | null;
    news_id: any;
    summary?: string | null;
    updated_at?: any | null;
    version: number;
    news: {
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    };
  }>;
};

export type CountNewsSummaryVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<NewsSummariesSelectColumn> | NewsSummariesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsSummariesOrderBy> | NewsSummariesOrderBy>;
  where?: InputMaybe<NewsSummariesBoolExp>;
}>;

export type CountNewsSummaryResponse = {
  __typename?: "query_root";
  news_summaries_aggregate: {
    __typename?: "news_summaries_aggregate";
    nodes: Array<{
      __typename?: "news_summaries";
      complexity_level?: any | null;
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      is_current?: boolean | null;
      news_id: any;
      summary?: string | null;
      updated_at?: any | null;
      version: number;
    }>;
  };
};

export type FetchOneNewsSummaryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneNewsSummaryResponse = {
  __typename?: "query_root";
  news_summaries_by_pk?: {
    __typename?: "news_summaries";
    complexity_level?: any | null;
    created_at?: any | null;
    embedding?: any | null;
    id: any;
    is_current?: boolean | null;
    news_id: any;
    summary?: string | null;
    updated_at?: any | null;
    version: number;
    news: {
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    };
  } | null;
};

export type FetchManyNewsTagVariables = Exact<{
  distinct_on?: InputMaybe<Array<NewsTagsSelectColumn> | NewsTagsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsTagsOrderBy> | NewsTagsOrderBy>;
  where?: InputMaybe<NewsTagsBoolExp>;
}>;

export type FetchManyNewsTagResponse = {
  __typename?: "query_root";
  news_tags: Array<{
    __typename?: "news_tags";
    id: number;
    news_id?: any | null;
    tag_id: number;
    tag: {
      __typename?: "tags";
      body?: string | null;
      created_at?: any | null;
      document_id?: string | null;
      id: number;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    };
  }>;
};

export type CountNewsTagVariables = Exact<{
  distinct_on?: InputMaybe<Array<NewsTagsSelectColumn> | NewsTagsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewsTagsOrderBy> | NewsTagsOrderBy>;
  where?: InputMaybe<NewsTagsBoolExp>;
}>;

export type CountNewsTagResponse = {
  __typename?: "query_root";
  news_tags_aggregate: {
    __typename?: "news_tags_aggregate";
    nodes: Array<{
      __typename?: "news_tags";
      id: number;
      news_id?: any | null;
      tag_id: number;
    }>;
  };
};

export type FetchOneNewsTagVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneNewsTagResponse = {
  __typename?: "query_root";
  news_tags_by_pk?: {
    __typename?: "news_tags";
    id: number;
    news_id?: any | null;
    tag_id: number;
    tag: {
      __typename?: "tags";
      body?: string | null;
      created_at?: any | null;
      document_id?: string | null;
      id: number;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    };
  } | null;
};

export type FetchManyNewsletterVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<NewslettersSelectColumn> | NewslettersSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewslettersOrderBy> | NewslettersOrderBy>;
  where?: InputMaybe<NewslettersBoolExp>;
}>;

export type FetchManyNewsletterResponse = {
  __typename?: "query_root";
  newsletters: Array<{
    __typename?: "newsletters";
    content_status: any;
    created_at?: any | null;
    end_date: any;
    frequency: string;
    generated_content?: string | null;
    id: any;
    start_date: any;
    title: string;
    updated_at?: any | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  }>;
};

export type CountNewsletterVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<NewslettersSelectColumn> | NewslettersSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<NewslettersOrderBy> | NewslettersOrderBy>;
  where?: InputMaybe<NewslettersBoolExp>;
}>;

export type CountNewsletterResponse = {
  __typename?: "query_root";
  newsletters_aggregate: {
    __typename?: "newsletters_aggregate";
    nodes: Array<{
      __typename?: "newsletters";
      content_status: any;
      created_at?: any | null;
      end_date: any;
      frequency: string;
      generated_content?: string | null;
      id: any;
      start_date: any;
      title: string;
      updated_at?: any | null;
    }>;
  };
};

export type FetchOneNewsletterVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneNewsletterResponse = {
  __typename?: "query_root";
  newsletters_by_pk?: {
    __typename?: "newsletters";
    content_status: any;
    created_at?: any | null;
    end_date: any;
    frequency: string;
    generated_content?: string | null;
    id: any;
    start_date: any;
    title: string;
    updated_at?: any | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type FetchManyPaymentProviderVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<PaymentProvidersSelectColumn> | PaymentProvidersSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<PaymentProvidersOrderBy> | PaymentProvidersOrderBy
  >;
  where?: InputMaybe<PaymentProvidersBoolExp>;
}>;

export type FetchManyPaymentProviderResponse = {
  __typename?: "query_root";
  payment_providers: Array<{
    __typename?: "payment_providers";
    created_at?: any | null;
    id: number;
    is_active?: boolean | null;
    name: string;
    updated_at?: any | null;
    customer_payments: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
    customer_subscriptions: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  }>;
};

export type CountPaymentProviderVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<PaymentProvidersSelectColumn> | PaymentProvidersSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<PaymentProvidersOrderBy> | PaymentProvidersOrderBy
  >;
  where?: InputMaybe<PaymentProvidersBoolExp>;
}>;

export type CountPaymentProviderResponse = {
  __typename?: "query_root";
  payment_providers_aggregate: {
    __typename?: "payment_providers_aggregate";
    nodes: Array<{
      __typename?: "payment_providers";
      created_at?: any | null;
      id: number;
      is_active?: boolean | null;
      name: string;
      updated_at?: any | null;
    }>;
  };
};

export type FetchOnePaymentProviderVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOnePaymentProviderResponse = {
  __typename?: "query_root";
  payment_providers_by_pk?: {
    __typename?: "payment_providers";
    created_at?: any | null;
    id: number;
    is_active?: boolean | null;
    name: string;
    updated_at?: any | null;
    customer_payments: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
    customer_subscriptions: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  } | null;
};

export type FetchManyPlanPermissionVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<PlanPermissionsSelectColumn> | PlanPermissionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<PlanPermissionsOrderBy> | PlanPermissionsOrderBy>;
  where?: InputMaybe<PlanPermissionsBoolExp>;
}>;

export type FetchManyPlanPermissionResponse = {
  __typename?: "query_root";
  plan_permissions: Array<{
    __typename?: "plan_permissions";
    feature: string;
    id: number;
    plan: any;
  }>;
};

export type CountPlanPermissionVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<PlanPermissionsSelectColumn> | PlanPermissionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<PlanPermissionsOrderBy> | PlanPermissionsOrderBy>;
  where?: InputMaybe<PlanPermissionsBoolExp>;
}>;

export type CountPlanPermissionResponse = {
  __typename?: "query_root";
  plan_permissions_aggregate: {
    __typename?: "plan_permissions_aggregate";
    nodes: Array<{
      __typename?: "plan_permissions";
      feature: string;
      id: number;
      plan: any;
    }>;
  };
};

export type FetchOnePlanPermissionVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOnePlanPermissionResponse = {
  __typename?: "query_root";
  plan_permissions_by_pk?: {
    __typename?: "plan_permissions";
    feature: string;
    id: number;
    plan: any;
  } | null;
};

export type FetchManyRecentErrorVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<RecentErrorsSelectColumn> | RecentErrorsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RecentErrorsOrderBy> | RecentErrorsOrderBy>;
  where?: InputMaybe<RecentErrorsBoolExp>;
}>;

export type FetchManyRecentErrorResponse = {
  __typename?: "query_root";
  recent_errors: Array<{
    __typename?: "recent_errors";
    created_at?: any | null;
    error_type?: any | null;
    message?: string | null;
    metadata?: any | null;
    service_name?: string | null;
    severity?: any | null;
  }>;
};

export type CountRecentErrorVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<RecentErrorsSelectColumn> | RecentErrorsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RecentErrorsOrderBy> | RecentErrorsOrderBy>;
  where?: InputMaybe<RecentErrorsBoolExp>;
}>;

export type CountRecentErrorResponse = {
  __typename?: "query_root";
  recent_errors_aggregate: {
    __typename?: "recent_errors_aggregate";
    nodes: Array<{
      __typename?: "recent_errors";
      created_at?: any | null;
      error_type?: any | null;
      message?: string | null;
      metadata?: any | null;
      service_name?: string | null;
      severity?: any | null;
    }>;
  };
};

export type FetchManyReferralStatVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ReferralStatsSelectColumn> | ReferralStatsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferralStatsOrderBy> | ReferralStatsOrderBy>;
  where?: InputMaybe<ReferralStatsBoolExp>;
}>;

export type FetchManyReferralStatResponse = {
  __typename?: "query_root";
  referral_stats: Array<{
    __typename?: "referral_stats";
    active_days?: any | null;
    avg_conversion_time_hours?: any | null;
    conversion_rate?: any | null;
    conversions?: any | null;
    referrer_code?: string | null;
    total_referrals?: any | null;
    total_value?: any | null;
    unique_visitors?: any | null;
  }>;
};

export type CountReferralStatVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ReferralStatsSelectColumn> | ReferralStatsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferralStatsOrderBy> | ReferralStatsOrderBy>;
  where?: InputMaybe<ReferralStatsBoolExp>;
}>;

export type CountReferralStatResponse = {
  __typename?: "query_root";
  referral_stats_aggregate: {
    __typename?: "referral_stats_aggregate";
    nodes: Array<{
      __typename?: "referral_stats";
      active_days?: any | null;
      avg_conversion_time_hours?: any | null;
      conversion_rate?: any | null;
      conversions?: any | null;
      referrer_code?: string | null;
      total_referrals?: any | null;
      total_value?: any | null;
      unique_visitors?: any | null;
    }>;
  };
};

export type FetchManyReferralVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ReferralsSelectColumn> | ReferralsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferralsOrderBy> | ReferralsOrderBy>;
  where?: InputMaybe<ReferralsBoolExp>;
}>;

export type FetchManyReferralResponse = {
  __typename?: "query_root";
  referrals: Array<{
    __typename?: "referrals";
    browser?: string | null;
    client_fingerprint?: string | null;
    conversion_value?: any | null;
    converted_at?: any | null;
    country_code?: string | null;
    created_at?: any | null;
    device_type?: string | null;
    id: any;
    ip_address?: any | null;
    is_suspicious?: boolean | null;
    landing_page?: string | null;
    last_failed_attempt?: any | null;
    referral_status?: any | null;
    referrer_code: string;
    region?: string | null;
    security_flags?: any | null;
    user_agent?: string | null;
    utm_campaign?: string | null;
    utm_medium?: string | null;
    utm_source?: string | null;
    validation_attempts?: number | null;
    visitor_id: any;
  }>;
};

export type CountReferralVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ReferralsSelectColumn> | ReferralsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferralsOrderBy> | ReferralsOrderBy>;
  where?: InputMaybe<ReferralsBoolExp>;
}>;

export type CountReferralResponse = {
  __typename?: "query_root";
  referrals_aggregate: {
    __typename?: "referrals_aggregate";
    nodes: Array<{
      __typename?: "referrals";
      browser?: string | null;
      client_fingerprint?: string | null;
      conversion_value?: any | null;
      converted_at?: any | null;
      country_code?: string | null;
      created_at?: any | null;
      device_type?: string | null;
      id: any;
      ip_address?: any | null;
      is_suspicious?: boolean | null;
      landing_page?: string | null;
      last_failed_attempt?: any | null;
      referral_status?: any | null;
      referrer_code: string;
      region?: string | null;
      security_flags?: any | null;
      user_agent?: string | null;
      utm_campaign?: string | null;
      utm_medium?: string | null;
      utm_source?: string | null;
      validation_attempts?: number | null;
      visitor_id: any;
    }>;
  };
};

export type FetchOneReferralVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneReferralResponse = {
  __typename?: "query_root";
  referrals_by_pk?: {
    __typename?: "referrals";
    browser?: string | null;
    client_fingerprint?: string | null;
    conversion_value?: any | null;
    converted_at?: any | null;
    country_code?: string | null;
    created_at?: any | null;
    device_type?: string | null;
    id: any;
    ip_address?: any | null;
    is_suspicious?: boolean | null;
    landing_page?: string | null;
    last_failed_attempt?: any | null;
    referral_status?: any | null;
    referrer_code: string;
    region?: string | null;
    security_flags?: any | null;
    user_agent?: string | null;
    utm_campaign?: string | null;
    utm_medium?: string | null;
    utm_source?: string | null;
    validation_attempts?: number | null;
    visitor_id: any;
  } | null;
};

export type FetchManyReferrerBlockVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ReferrerBlocksSelectColumn> | ReferrerBlocksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferrerBlocksOrderBy> | ReferrerBlocksOrderBy>;
  where?: InputMaybe<ReferrerBlocksBoolExp>;
}>;

export type FetchManyReferrerBlockResponse = {
  __typename?: "query_root";
  referrer_blocks: Array<{
    __typename?: "referrer_blocks";
    blocked_at?: any | null;
    blocked_by: string;
    created_at?: any | null;
    id: any;
    is_permanent?: boolean | null;
    reason?: string | null;
    referrer_code: string;
    updated_at?: any | null;
  }>;
};

export type CountReferrerBlockVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ReferrerBlocksSelectColumn> | ReferrerBlocksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ReferrerBlocksOrderBy> | ReferrerBlocksOrderBy>;
  where?: InputMaybe<ReferrerBlocksBoolExp>;
}>;

export type CountReferrerBlockResponse = {
  __typename?: "query_root";
  referrer_blocks_aggregate: {
    __typename?: "referrer_blocks_aggregate";
    nodes: Array<{
      __typename?: "referrer_blocks";
      blocked_at?: any | null;
      blocked_by: string;
      created_at?: any | null;
      id: any;
      is_permanent?: boolean | null;
      reason?: string | null;
      referrer_code: string;
      updated_at?: any | null;
    }>;
  };
};

export type FetchOneReferrerBlockVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneReferrerBlockResponse = {
  __typename?: "query_root";
  referrer_blocks_by_pk?: {
    __typename?: "referrer_blocks";
    blocked_at?: any | null;
    blocked_by: string;
    created_at?: any | null;
    id: any;
    is_permanent?: boolean | null;
    reason?: string | null;
    referrer_code: string;
    updated_at?: any | null;
  } | null;
};

export type FetchManyReferrerRiskMetricVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ReferrerRiskMetricsSelectColumn> | ReferrerRiskMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<ReferrerRiskMetricsOrderBy> | ReferrerRiskMetricsOrderBy
  >;
  where?: InputMaybe<ReferrerRiskMetricsBoolExp>;
}>;

export type FetchManyReferrerRiskMetricResponse = {
  __typename?: "query_root";
  referrer_risk_metrics: Array<{
    __typename?: "referrer_risk_metrics";
    active_days?: any | null;
    high_attempt_instances?: any | null;
    max_validation_attempts?: number | null;
    referrer_code?: string | null;
    suspicious_count?: any | null;
    suspicious_percentage?: any | null;
    total_referrals?: any | null;
    unique_ips?: any | null;
  }>;
};

export type CountReferrerRiskMetricVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ReferrerRiskMetricsSelectColumn> | ReferrerRiskMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<ReferrerRiskMetricsOrderBy> | ReferrerRiskMetricsOrderBy
  >;
  where?: InputMaybe<ReferrerRiskMetricsBoolExp>;
}>;

export type CountReferrerRiskMetricResponse = {
  __typename?: "query_root";
  referrer_risk_metrics_aggregate: {
    __typename?: "referrer_risk_metrics_aggregate";
    nodes: Array<{
      __typename?: "referrer_risk_metrics";
      active_days?: any | null;
      high_attempt_instances?: any | null;
      max_validation_attempts?: number | null;
      referrer_code?: string | null;
      suspicious_count?: any | null;
      suspicious_percentage?: any | null;
      total_referrals?: any | null;
      unique_ips?: any | null;
    }>;
  };
};

export type FetchManyResearchVariables = Exact<{
  distinct_on?: InputMaybe<Array<ResearchSelectColumn> | ResearchSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResearchOrderBy> | ResearchOrderBy>;
  where?: InputMaybe<ResearchBoolExp>;
}>;

export type FetchManyResearchResponse = {
  __typename?: "query_root";
  research: Array<{
    __typename?: "research";
    abstract?: string | null;
    abstract_url: string;
    affiliations?: any | null;
    authors?: any | null;
    category?: string | null;
    comments?: string | null;
    content_status: any;
    created_at: any;
    doi_url?: string | null;
    figure_count?: any | null;
    has_embedding?: boolean | null;
    id: any;
    is_flagged: boolean;
    keywords?: string | null;
    month?: string | null;
    page_count?: any | null;
    pdf_url?: string | null;
    published_at?: any | null;
    published_in?: string | null;
    summary?: string | null;
    table_count?: any | null;
    title?: string | null;
    updated_at?: any | null;
    version?: any | null;
    year?: string | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    research_embedding?: {
      __typename?: "research_embeddings";
      chunk: string;
      created_at?: any | null;
      embedding?: any | null;
      embedding_review_id?: any | null;
      id: number;
      is_flagged?: boolean | null;
      research_id: any;
      updated_at: any;
      url?: string | null;
    } | null;
  }>;
};

export type CountResearchVariables = Exact<{
  distinct_on?: InputMaybe<Array<ResearchSelectColumn> | ResearchSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResearchOrderBy> | ResearchOrderBy>;
  where?: InputMaybe<ResearchBoolExp>;
}>;

export type CountResearchResponse = {
  __typename?: "query_root";
  research_aggregate: {
    __typename?: "research_aggregate";
    nodes: Array<{
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
    }>;
  };
};

export type FetchOneResearchVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneResearchResponse = {
  __typename?: "query_root";
  research_by_pk?: {
    __typename?: "research";
    abstract?: string | null;
    abstract_url: string;
    affiliations?: any | null;
    authors?: any | null;
    category?: string | null;
    comments?: string | null;
    content_status: any;
    created_at: any;
    doi_url?: string | null;
    figure_count?: any | null;
    has_embedding?: boolean | null;
    id: any;
    is_flagged: boolean;
    keywords?: string | null;
    month?: string | null;
    page_count?: any | null;
    pdf_url?: string | null;
    published_at?: any | null;
    published_in?: string | null;
    summary?: string | null;
    table_count?: any | null;
    title?: string | null;
    updated_at?: any | null;
    version?: any | null;
    year?: string | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    research_embedding?: {
      __typename?: "research_embeddings";
      chunk: string;
      created_at?: any | null;
      embedding?: any | null;
      embedding_review_id?: any | null;
      id: number;
      is_flagged?: boolean | null;
      research_id: any;
      updated_at: any;
      url?: string | null;
    } | null;
  } | null;
};

export type FetchManyResearchEmbeddingVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ResearchEmbeddingsSelectColumn> | ResearchEmbeddingsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<ResearchEmbeddingsOrderBy> | ResearchEmbeddingsOrderBy
  >;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
}>;

export type FetchManyResearchEmbeddingResponse = {
  __typename?: "query_root";
  research_embeddings: Array<{
    __typename?: "research_embeddings";
    chunk: string;
    created_at?: any | null;
    embedding?: any | null;
    embedding_review_id?: any | null;
    id: number;
    is_flagged?: boolean | null;
    research_id: any;
    updated_at: any;
    url?: string | null;
    embedding_review?: {
      __typename?: "embedding_reviews";
      agent_review?: boolean | null;
      created_at: any;
      human_review?: boolean | null;
      id: any;
      notes?: string | null;
      updated_at?: any | null;
    } | null;
    research: {
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
    };
  }>;
};

export type CountResearchEmbeddingVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ResearchEmbeddingsSelectColumn> | ResearchEmbeddingsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<ResearchEmbeddingsOrderBy> | ResearchEmbeddingsOrderBy
  >;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
}>;

export type CountResearchEmbeddingResponse = {
  __typename?: "query_root";
  research_embeddings_aggregate: {
    __typename?: "research_embeddings_aggregate";
    nodes: Array<{
      __typename?: "research_embeddings";
      chunk: string;
      created_at?: any | null;
      embedding?: any | null;
      embedding_review_id?: any | null;
      id: number;
      is_flagged?: boolean | null;
      research_id: any;
      updated_at: any;
      url?: string | null;
    }>;
  };
};

export type FetchOneResearchEmbeddingVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneResearchEmbeddingResponse = {
  __typename?: "query_root";
  research_embeddings_by_pk?: {
    __typename?: "research_embeddings";
    chunk: string;
    created_at?: any | null;
    embedding?: any | null;
    embedding_review_id?: any | null;
    id: number;
    is_flagged?: boolean | null;
    research_id: any;
    updated_at: any;
    url?: string | null;
    embedding_review?: {
      __typename?: "embedding_reviews";
      agent_review?: boolean | null;
      created_at: any;
      human_review?: boolean | null;
      id: any;
      notes?: string | null;
      updated_at?: any | null;
    } | null;
    research: {
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
    };
  } | null;
};

export type FetchManyResponseVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ResponsesSelectColumn> | ResponsesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResponsesOrderBy> | ResponsesOrderBy>;
  where?: InputMaybe<ResponsesBoolExp>;
}>;

export type FetchManyResponseResponse = {
  __typename?: "query_root";
  responses: Array<{
    __typename?: "responses";
    created_at?: any | null;
    downvotes?: number | null;
    id: any;
    output: string;
    search_id: any;
    upvotes?: number | null;
    search: {
      __typename?: "searches";
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      input: string;
      tokens_used?: any | null;
      user_ids?: Array<any> | null;
    };
  }>;
};

export type CountResponseVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ResponsesSelectColumn> | ResponsesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ResponsesOrderBy> | ResponsesOrderBy>;
  where?: InputMaybe<ResponsesBoolExp>;
}>;

export type CountResponseResponse = {
  __typename?: "query_root";
  responses_aggregate: {
    __typename?: "responses_aggregate";
    nodes: Array<{
      __typename?: "responses";
      created_at?: any | null;
      downvotes?: number | null;
      id: any;
      output: string;
      search_id: any;
      upvotes?: number | null;
    }>;
  };
};

export type FetchOneResponseVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneResponseResponse = {
  __typename?: "query_root";
  responses_by_pk?: {
    __typename?: "responses";
    created_at?: any | null;
    downvotes?: number | null;
    id: any;
    output: string;
    search_id: any;
    upvotes?: number | null;
    search: {
      __typename?: "searches";
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      input: string;
      tokens_used?: any | null;
      user_ids?: Array<any> | null;
    };
  } | null;
};

export type FetchManyRoleHierarchyVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<RoleHierarchySelectColumn> | RoleHierarchySelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RoleHierarchyOrderBy> | RoleHierarchyOrderBy>;
  where?: InputMaybe<RoleHierarchyBoolExp>;
}>;

export type FetchManyRoleHierarchyResponse = {
  __typename?: "query_root";
  role_hierarchy: Array<{
    __typename?: "role_hierarchy";
    child_role: any;
    parent_role: any;
  }>;
};

export type CountRoleHierarchyVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<RoleHierarchySelectColumn> | RoleHierarchySelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RoleHierarchyOrderBy> | RoleHierarchyOrderBy>;
  where?: InputMaybe<RoleHierarchyBoolExp>;
}>;

export type CountRoleHierarchyResponse = {
  __typename?: "query_root";
  role_hierarchy_aggregate: {
    __typename?: "role_hierarchy_aggregate";
    nodes: Array<{
      __typename?: "role_hierarchy";
      child_role: any;
      parent_role: any;
    }>;
  };
};

export type FetchOneRoleHierarchyVariables = Exact<{
  child_role: Scalars["app_role_enum"]["input"];
  parent_role: Scalars["app_role_enum"]["input"];
}>;

export type FetchOneRoleHierarchyResponse = {
  __typename?: "query_root";
  role_hierarchy_by_pk?: {
    __typename?: "role_hierarchy";
    child_role: any;
    parent_role: any;
  } | null;
};

export type FetchManyRolePermissionVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<RolePermissionsSelectColumn> | RolePermissionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RolePermissionsOrderBy> | RolePermissionsOrderBy>;
  where?: InputMaybe<RolePermissionsBoolExp>;
}>;

export type FetchManyRolePermissionResponse = {
  __typename?: "query_root";
  role_permissions: Array<{
    __typename?: "role_permissions";
    cached_permissions?: any | null;
    conditions?: any | null;
    id: number;
    inherit_from?: Array<any> | null;
    last_updated?: any | null;
    permissions?: any | null;
    role: any;
    table_name: string;
  }>;
};

export type CountRolePermissionVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<RolePermissionsSelectColumn> | RolePermissionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<RolePermissionsOrderBy> | RolePermissionsOrderBy>;
  where?: InputMaybe<RolePermissionsBoolExp>;
}>;

export type CountRolePermissionResponse = {
  __typename?: "query_root";
  role_permissions_aggregate: {
    __typename?: "role_permissions_aggregate";
    nodes: Array<{
      __typename?: "role_permissions";
      cached_permissions?: any | null;
      conditions?: any | null;
      id: number;
      inherit_from?: Array<any> | null;
      last_updated?: any | null;
      permissions?: any | null;
      role: any;
      table_name: string;
    }>;
  };
};

export type FetchOneRolePermissionVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneRolePermissionResponse = {
  __typename?: "query_root";
  role_permissions_by_pk?: {
    __typename?: "role_permissions";
    cached_permissions?: any | null;
    conditions?: any | null;
    id: number;
    inherit_from?: Array<any> | null;
    last_updated?: any | null;
    permissions?: any | null;
    role: any;
    table_name: string;
  } | null;
};

export type FetchManyRolePermissionsMaterializedVariables = Exact<{
  distinct_on?: InputMaybe<
    | Array<RolePermissionsMaterializedSelectColumn>
    | RolePermissionsMaterializedSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    | Array<RolePermissionsMaterializedOrderBy>
    | RolePermissionsMaterializedOrderBy
  >;
  where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
}>;

export type FetchManyRolePermissionsMaterializedResponse = {
  __typename?: "query_root";
  role_permissions_materialized: Array<{
    __typename?: "role_permissions_materialized";
    last_updated?: any | null;
    permissions: any;
    role: any;
  }>;
};

export type CountRolePermissionsMaterializedVariables = Exact<{
  distinct_on?: InputMaybe<
    | Array<RolePermissionsMaterializedSelectColumn>
    | RolePermissionsMaterializedSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    | Array<RolePermissionsMaterializedOrderBy>
    | RolePermissionsMaterializedOrderBy
  >;
  where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
}>;

export type CountRolePermissionsMaterializedResponse = {
  __typename?: "query_root";
  role_permissions_materialized_aggregate: {
    __typename?: "role_permissions_materialized_aggregate";
    nodes: Array<{
      __typename?: "role_permissions_materialized";
      last_updated?: any | null;
      permissions: any;
      role: any;
    }>;
  };
};

export type FetchOneRolePermissionsMaterializedVariables = Exact<{
  role: Scalars["app_role_enum"]["input"];
}>;

export type FetchOneRolePermissionsMaterializedResponse = {
  __typename?: "query_root";
  role_permissions_materialized_by_pk?: {
    __typename?: "role_permissions_materialized";
    last_updated?: any | null;
    permissions: any;
    role: any;
  } | null;
};

export type FetchManyScoringWeightVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ScoringWeightsSelectColumn> | ScoringWeightsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ScoringWeightsOrderBy> | ScoringWeightsOrderBy>;
  where?: InputMaybe<ScoringWeightsBoolExp>;
}>;

export type FetchManyScoringWeightResponse = {
  __typename?: "query_root";
  scoring_weights: Array<{
    __typename?: "scoring_weights";
    description?: string | null;
    id: any;
    name: string;
    updated_at?: any | null;
    weight: any;
  }>;
};

export type CountScoringWeightVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<ScoringWeightsSelectColumn> | ScoringWeightsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<ScoringWeightsOrderBy> | ScoringWeightsOrderBy>;
  where?: InputMaybe<ScoringWeightsBoolExp>;
}>;

export type CountScoringWeightResponse = {
  __typename?: "query_root";
  scoring_weights_aggregate: {
    __typename?: "scoring_weights_aggregate";
    nodes: Array<{
      __typename?: "scoring_weights";
      description?: string | null;
      id: any;
      name: string;
      updated_at?: any | null;
      weight: any;
    }>;
  };
};

export type FetchOneScoringWeightVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneScoringWeightResponse = {
  __typename?: "query_root";
  scoring_weights_by_pk?: {
    __typename?: "scoring_weights";
    description?: string | null;
    id: any;
    name: string;
    updated_at?: any | null;
    weight: any;
  } | null;
};

export type FetchManySearchVariables = Exact<{
  distinct_on?: InputMaybe<Array<SearchesSelectColumn> | SearchesSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SearchesOrderBy> | SearchesOrderBy>;
  where?: InputMaybe<SearchesBoolExp>;
}>;

export type FetchManySearchResponse = {
  __typename?: "query_root";
  searches: Array<{
    __typename?: "searches";
    created_at?: any | null;
    embedding?: any | null;
    id: any;
    input: string;
    tokens_used?: any | null;
    user_ids?: Array<any> | null;
    responses: Array<{
      __typename?: "responses";
      created_at?: any | null;
      downvotes?: number | null;
      id: any;
      output: string;
      search_id: any;
      upvotes?: number | null;
    }>;
  }>;
};

export type CountSearchVariables = Exact<{
  distinct_on?: InputMaybe<Array<SearchesSelectColumn> | SearchesSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SearchesOrderBy> | SearchesOrderBy>;
  where?: InputMaybe<SearchesBoolExp>;
}>;

export type CountSearchResponse = {
  __typename?: "query_root";
  searches_aggregate: {
    __typename?: "searches_aggregate";
    nodes: Array<{
      __typename?: "searches";
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      input: string;
      tokens_used?: any | null;
      user_ids?: Array<any> | null;
    }>;
  };
};

export type FetchOneSearchVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneSearchResponse = {
  __typename?: "query_root";
  searches_by_pk?: {
    __typename?: "searches";
    created_at?: any | null;
    embedding?: any | null;
    id: any;
    input: string;
    tokens_used?: any | null;
    user_ids?: Array<any> | null;
    responses: Array<{
      __typename?: "responses";
      created_at?: any | null;
      downvotes?: number | null;
      id: any;
      output: string;
      search_id: any;
      upvotes?: number | null;
    }>;
  } | null;
};

export type FetchManySecurityMetricVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<SecurityMetricsSelectColumn> | SecurityMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SecurityMetricsOrderBy> | SecurityMetricsOrderBy>;
  where?: InputMaybe<SecurityMetricsBoolExp>;
}>;

export type FetchManySecurityMetricResponse = {
  __typename?: "query_root";
  security_metrics: Array<{
    __typename?: "security_metrics";
    high_attempt_count?: any | null;
    max_attempts?: number | null;
    suspicious_attempts?: any | null;
    time_bucket?: any | null;
    total_attempts?: any | null;
    unique_ips?: any | null;
    unique_referrers?: any | null;
  }>;
};

export type CountSecurityMetricVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<SecurityMetricsSelectColumn> | SecurityMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SecurityMetricsOrderBy> | SecurityMetricsOrderBy>;
  where?: InputMaybe<SecurityMetricsBoolExp>;
}>;

export type CountSecurityMetricResponse = {
  __typename?: "query_root";
  security_metrics_aggregate: {
    __typename?: "security_metrics_aggregate";
    nodes: Array<{
      __typename?: "security_metrics";
      high_attempt_count?: any | null;
      max_attempts?: number | null;
      suspicious_attempts?: any | null;
      time_bucket?: any | null;
      total_attempts?: any | null;
      unique_ips?: any | null;
      unique_referrers?: any | null;
    }>;
  };
};

export type FetchManySlowQueryPatternVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<SlowQueryPatternsSelectColumn> | SlowQueryPatternsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<SlowQueryPatternsOrderBy> | SlowQueryPatternsOrderBy
  >;
  where?: InputMaybe<SlowQueryPatternsBoolExp>;
}>;

export type FetchManySlowQueryPatternResponse = {
  __typename?: "query_root";
  slow_query_patterns: Array<{
    __typename?: "slow_query_patterns";
    avg_exec_time?: any | null;
    first_seen?: any | null;
    last_seen?: any | null;
    max_exec_time?: any | null;
    occurrence_count?: any | null;
    query_id?: string | null;
  }>;
};

export type CountSlowQueryPatternVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<SlowQueryPatternsSelectColumn> | SlowQueryPatternsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<SlowQueryPatternsOrderBy> | SlowQueryPatternsOrderBy
  >;
  where?: InputMaybe<SlowQueryPatternsBoolExp>;
}>;

export type CountSlowQueryPatternResponse = {
  __typename?: "query_root";
  slow_query_patterns_aggregate: {
    __typename?: "slow_query_patterns_aggregate";
    nodes: Array<{
      __typename?: "slow_query_patterns";
      avg_exec_time?: any | null;
      first_seen?: any | null;
      last_seen?: any | null;
      max_exec_time?: any | null;
      occurrence_count?: any | null;
      query_id?: string | null;
    }>;
  };
};

export type FetchManySocialMediaVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<SocialMediaSelectColumn> | SocialMediaSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SocialMediaOrderBy> | SocialMediaOrderBy>;
  where?: InputMaybe<SocialMediaBoolExp>;
}>;

export type FetchManySocialMediaResponse = {
  __typename?: "query_root";
  social_media: Array<{
    __typename?: "social_media";
    created_at?: any | null;
    facebook_url?: string | null;
    id: number;
    instagram_url?: string | null;
    linkedin_url?: string | null;
    twitter_url?: string | null;
    updated_at?: any | null;
    youtube_url?: string | null;
    companies: Array<{
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    }>;
  }>;
};

export type CountSocialMediaVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<SocialMediaSelectColumn> | SocialMediaSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SocialMediaOrderBy> | SocialMediaOrderBy>;
  where?: InputMaybe<SocialMediaBoolExp>;
}>;

export type CountSocialMediaResponse = {
  __typename?: "query_root";
  social_media_aggregate: {
    __typename?: "social_media_aggregate";
    nodes: Array<{
      __typename?: "social_media";
      created_at?: any | null;
      facebook_url?: string | null;
      id: number;
      instagram_url?: string | null;
      linkedin_url?: string | null;
      twitter_url?: string | null;
      updated_at?: any | null;
      youtube_url?: string | null;
    }>;
  };
};

export type FetchOneSocialMediaVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneSocialMediaResponse = {
  __typename?: "query_root";
  social_media_by_pk?: {
    __typename?: "social_media";
    created_at?: any | null;
    facebook_url?: string | null;
    id: number;
    instagram_url?: string | null;
    linkedin_url?: string | null;
    twitter_url?: string | null;
    updated_at?: any | null;
    youtube_url?: string | null;
    companies: Array<{
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    }>;
  } | null;
};

export type FetchManySpiderMetricVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<SpiderMetricsSelectColumn> | SpiderMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SpiderMetricsOrderBy> | SpiderMetricsOrderBy>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
}>;

export type FetchManySpiderMetricResponse = {
  __typename?: "query_root";
  spider_metrics: Array<{
    __typename?: "spider_metrics";
    crawl_id: any;
    id: any;
    metric_id?: number | null;
    timestamp: any;
    value: any;
    metric_definition?: {
      __typename?: "metric_definitions";
      category?: string | null;
      description?: string | null;
      id: number;
      is_dimensional?: boolean | null;
      name: string;
      type: string;
      unit?: string | null;
    } | null;
  }>;
};

export type CountSpiderMetricVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<SpiderMetricsSelectColumn> | SpiderMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<SpiderMetricsOrderBy> | SpiderMetricsOrderBy>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
}>;

export type CountSpiderMetricResponse = {
  __typename?: "query_root";
  spider_metrics_aggregate: {
    __typename?: "spider_metrics_aggregate";
    nodes: Array<{
      __typename?: "spider_metrics";
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
    }>;
  };
};

export type FetchOneSpiderMetricVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneSpiderMetricResponse = {
  __typename?: "query_root";
  spider_metrics_by_pk?: {
    __typename?: "spider_metrics";
    crawl_id: any;
    id: any;
    metric_id?: number | null;
    timestamp: any;
    value: any;
    metric_definition?: {
      __typename?: "metric_definitions";
      category?: string | null;
      description?: string | null;
      id: number;
      is_dimensional?: boolean | null;
      name: string;
      type: string;
      unit?: string | null;
    } | null;
  } | null;
};

export type FetchManyStrapiMigrationVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<StrapiMigrationsSelectColumn> | StrapiMigrationsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<StrapiMigrationsOrderBy> | StrapiMigrationsOrderBy
  >;
  where?: InputMaybe<StrapiMigrationsBoolExp>;
}>;

export type FetchManyStrapiMigrationResponse = {
  __typename?: "query_root";
  strapi_migrations: Array<{
    __typename?: "strapi_migrations";
    id: number;
    name?: string | null;
    time?: any | null;
  }>;
};

export type CountStrapiMigrationVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<StrapiMigrationsSelectColumn> | StrapiMigrationsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<StrapiMigrationsOrderBy> | StrapiMigrationsOrderBy
  >;
  where?: InputMaybe<StrapiMigrationsBoolExp>;
}>;

export type CountStrapiMigrationResponse = {
  __typename?: "query_root";
  strapi_migrations_aggregate: {
    __typename?: "strapi_migrations_aggregate";
    nodes: Array<{
      __typename?: "strapi_migrations";
      id: number;
      name?: string | null;
      time?: any | null;
    }>;
  };
};

export type FetchOneStrapiMigrationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneStrapiMigrationResponse = {
  __typename?: "query_root";
  strapi_migrations_by_pk?: {
    __typename?: "strapi_migrations";
    id: number;
    name?: string | null;
    time?: any | null;
  } | null;
};

export type FetchManyStrapiMigrationsInternalVariables = Exact<{
  distinct_on?: InputMaybe<
    | Array<StrapiMigrationsInternalSelectColumn>
    | StrapiMigrationsInternalSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<StrapiMigrationsInternalOrderBy> | StrapiMigrationsInternalOrderBy
  >;
  where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
}>;

export type FetchManyStrapiMigrationsInternalResponse = {
  __typename?: "query_root";
  strapi_migrations_internal: Array<{
    __typename?: "strapi_migrations_internal";
    id: number;
    name?: string | null;
    time?: any | null;
  }>;
};

export type CountStrapiMigrationsInternalVariables = Exact<{
  distinct_on?: InputMaybe<
    | Array<StrapiMigrationsInternalSelectColumn>
    | StrapiMigrationsInternalSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<StrapiMigrationsInternalOrderBy> | StrapiMigrationsInternalOrderBy
  >;
  where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
}>;

export type CountStrapiMigrationsInternalResponse = {
  __typename?: "query_root";
  strapi_migrations_internal_aggregate: {
    __typename?: "strapi_migrations_internal_aggregate";
    nodes: Array<{
      __typename?: "strapi_migrations_internal";
      id: number;
      name?: string | null;
      time?: any | null;
    }>;
  };
};

export type FetchOneStrapiMigrationsInternalVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneStrapiMigrationsInternalResponse = {
  __typename?: "query_root";
  strapi_migrations_internal_by_pk?: {
    __typename?: "strapi_migrations_internal";
    id: number;
    name?: string | null;
    time?: any | null;
  } | null;
};

export type FetchManyTableMaintenanceLogVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<TableMaintenanceLogSelectColumn> | TableMaintenanceLogSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<TableMaintenanceLogOrderBy> | TableMaintenanceLogOrderBy
  >;
  where?: InputMaybe<TableMaintenanceLogBoolExp>;
}>;

export type FetchManyTableMaintenanceLogResponse = {
  __typename?: "query_root";
  table_maintenance_log: Array<{
    __typename?: "table_maintenance_log";
    detail?: string | null;
    id: number;
    logged_at?: any | null;
    operation?: string | null;
  }>;
};

export type CountTableMaintenanceLogVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<TableMaintenanceLogSelectColumn> | TableMaintenanceLogSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<TableMaintenanceLogOrderBy> | TableMaintenanceLogOrderBy
  >;
  where?: InputMaybe<TableMaintenanceLogBoolExp>;
}>;

export type CountTableMaintenanceLogResponse = {
  __typename?: "query_root";
  table_maintenance_log_aggregate: {
    __typename?: "table_maintenance_log_aggregate";
    nodes: Array<{
      __typename?: "table_maintenance_log";
      detail?: string | null;
      id: number;
      logged_at?: any | null;
      operation?: string | null;
    }>;
  };
};

export type FetchOneTableMaintenanceLogVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneTableMaintenanceLogResponse = {
  __typename?: "query_root";
  table_maintenance_log_by_pk?: {
    __typename?: "table_maintenance_log";
    detail?: string | null;
    id: number;
    logged_at?: any | null;
    operation?: string | null;
  } | null;
};

export type FetchManyTableQueryPerformanceVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<TableQueryPerformanceSelectColumn> | TableQueryPerformanceSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<TableQueryPerformanceOrderBy> | TableQueryPerformanceOrderBy
  >;
  where?: InputMaybe<TableQueryPerformanceBoolExp>;
}>;

export type FetchManyTableQueryPerformanceResponse = {
  __typename?: "query_root";
  table_query_performance: Array<{
    __typename?: "table_query_performance";
    avg_duration?: any | null;
    capture_time?: any | null;
    execution_count?: any | null;
    query?: string | null;
  }>;
};

export type CountTableQueryPerformanceVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<TableQueryPerformanceSelectColumn> | TableQueryPerformanceSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<TableQueryPerformanceOrderBy> | TableQueryPerformanceOrderBy
  >;
  where?: InputMaybe<TableQueryPerformanceBoolExp>;
}>;

export type CountTableQueryPerformanceResponse = {
  __typename?: "query_root";
  table_query_performance_aggregate: {
    __typename?: "table_query_performance_aggregate";
    nodes: Array<{
      __typename?: "table_query_performance";
      avg_duration?: any | null;
      capture_time?: any | null;
      execution_count?: any | null;
      query?: string | null;
    }>;
  };
};

export type FetchManyTableSequenceUsageVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<TableSequenceUsageSelectColumn> | TableSequenceUsageSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<TableSequenceUsageOrderBy> | TableSequenceUsageOrderBy
  >;
  where?: InputMaybe<TableSequenceUsageBoolExp>;
}>;

export type FetchManyTableSequenceUsageResponse = {
  __typename?: "query_root";
  table_sequence_usage: Array<{
    __typename?: "table_sequence_usage";
    capture_time?: any | null;
    current_value?: any | null;
    max_value?: any | null;
    sequence_name?: string | null;
  }>;
};

export type CountTableSequenceUsageVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<TableSequenceUsageSelectColumn> | TableSequenceUsageSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<TableSequenceUsageOrderBy> | TableSequenceUsageOrderBy
  >;
  where?: InputMaybe<TableSequenceUsageBoolExp>;
}>;

export type CountTableSequenceUsageResponse = {
  __typename?: "query_root";
  table_sequence_usage_aggregate: {
    __typename?: "table_sequence_usage_aggregate";
    nodes: Array<{
      __typename?: "table_sequence_usage";
      capture_time?: any | null;
      current_value?: any | null;
      max_value?: any | null;
      sequence_name?: string | null;
    }>;
  };
};

export type FetchManyTableStatisticVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<TableStatisticsSelectColumn> | TableStatisticsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableStatisticsOrderBy> | TableStatisticsOrderBy>;
  where?: InputMaybe<TableStatisticsBoolExp>;
}>;

export type FetchManyTableStatisticResponse = {
  __typename?: "query_root";
  table_statistics: Array<{
    __typename?: "table_statistics";
    buffer_cache_hit_ratio?: any | null;
    capture_time: any;
    dead_tuples?: any | null;
    estimated_bloat_ratio?: any | null;
    index_scan_count?: any | null;
    index_size?: any | null;
    index_usage?: any | null;
    last_analyze?: any | null;
    last_vacuum?: any | null;
    live_tuples?: any | null;
    row_count?: any | null;
    seq_scan_count?: any | null;
    table_name: string;
    table_size?: any | null;
  }>;
};

export type CountTableStatisticVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<TableStatisticsSelectColumn> | TableStatisticsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TableStatisticsOrderBy> | TableStatisticsOrderBy>;
  where?: InputMaybe<TableStatisticsBoolExp>;
}>;

export type CountTableStatisticResponse = {
  __typename?: "query_root";
  table_statistics_aggregate: {
    __typename?: "table_statistics_aggregate";
    nodes: Array<{
      __typename?: "table_statistics";
      buffer_cache_hit_ratio?: any | null;
      capture_time: any;
      dead_tuples?: any | null;
      estimated_bloat_ratio?: any | null;
      index_scan_count?: any | null;
      index_size?: any | null;
      index_usage?: any | null;
      last_analyze?: any | null;
      last_vacuum?: any | null;
      live_tuples?: any | null;
      row_count?: any | null;
      seq_scan_count?: any | null;
      table_name: string;
      table_size?: any | null;
    }>;
  };
};

export type FetchOneTableStatisticVariables = Exact<{
  capture_time: Scalars["timestamptz"]["input"];
  table_name: Scalars["String"]["input"];
}>;

export type FetchOneTableStatisticResponse = {
  __typename?: "query_root";
  table_statistics_by_pk?: {
    __typename?: "table_statistics";
    buffer_cache_hit_ratio?: any | null;
    capture_time: any;
    dead_tuples?: any | null;
    estimated_bloat_ratio?: any | null;
    index_scan_count?: any | null;
    index_size?: any | null;
    index_usage?: any | null;
    last_analyze?: any | null;
    last_vacuum?: any | null;
    live_tuples?: any | null;
    row_count?: any | null;
    seq_scan_count?: any | null;
    table_name: string;
    table_size?: any | null;
  } | null;
};

export type FetchManyTagVariables = Exact<{
  distinct_on?: InputMaybe<Array<TagsSelectColumn> | TagsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TagsOrderBy> | TagsOrderBy>;
  where?: InputMaybe<TagsBoolExp>;
}>;

export type FetchManyTagResponse = {
  __typename?: "query_root";
  tags: Array<{
    __typename?: "tags";
    body?: string | null;
    created_at?: any | null;
    document_id?: string | null;
    id: number;
    locale?: string | null;
    name: string;
    published_at?: string | null;
    updated_at?: any | null;
    content_tags: Array<{
      __typename?: "content_tags";
      content_id: any;
      tag_id: number;
    }>;
    news_tags: Array<{
      __typename?: "news_tags";
      id: number;
      news_id?: any | null;
      tag_id: number;
    }>;
  }>;
};

export type CountTagVariables = Exact<{
  distinct_on?: InputMaybe<Array<TagsSelectColumn> | TagsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<TagsOrderBy> | TagsOrderBy>;
  where?: InputMaybe<TagsBoolExp>;
}>;

export type CountTagResponse = {
  __typename?: "query_root";
  tags_aggregate: {
    __typename?: "tags_aggregate";
    nodes: Array<{
      __typename?: "tags";
      body?: string | null;
      created_at?: any | null;
      document_id?: string | null;
      id: number;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    }>;
  };
};

export type FetchOneTagVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneTagResponse = {
  __typename?: "query_root";
  tags_by_pk?: {
    __typename?: "tags";
    body?: string | null;
    created_at?: any | null;
    document_id?: string | null;
    id: number;
    locale?: string | null;
    name: string;
    published_at?: string | null;
    updated_at?: any | null;
    content_tags: Array<{
      __typename?: "content_tags";
      content_id: any;
      tag_id: number;
    }>;
    news_tags: Array<{
      __typename?: "news_tags";
      id: number;
      news_id?: any | null;
      tag_id: number;
    }>;
  } | null;
};

export type FetchManyUserMetricVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<UserMetricsSelectColumn> | UserMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<UserMetricsOrderBy> | UserMetricsOrderBy>;
  where?: InputMaybe<UserMetricsBoolExp>;
}>;

export type FetchManyUserMetricResponse = {
  __typename?: "query_root";
  user_metrics: Array<{
    __typename?: "user_metrics";
    achievements?: any | null;
    best_streak?: number | null;
    created_at?: any | null;
    current_level?: number | null;
    current_streak?: number | null;
    current_xp?: number | null;
    downvote_count?: number | null;
    id: any;
    interaction_stats?: any | null;
    last_vote_date?: any | null;
    multipliers?: any | null;
    points?: number | null;
    points_breakdown?: any | null;
    titles?: any | null;
    today_vote_count?: number | null;
    total_reading_time?: number | null;
    total_votes?: number | null;
    updated_at?: any | null;
    upvote_count?: number | null;
    user_id: any;
    vote_accuracy?: any | null;
    xp_to_next_level?: number | null;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  }>;
};

export type CountUserMetricVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<UserMetricsSelectColumn> | UserMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<UserMetricsOrderBy> | UserMetricsOrderBy>;
  where?: InputMaybe<UserMetricsBoolExp>;
}>;

export type CountUserMetricResponse = {
  __typename?: "query_root";
  user_metrics_aggregate: {
    __typename?: "user_metrics_aggregate";
    nodes: Array<{
      __typename?: "user_metrics";
      achievements?: any | null;
      best_streak?: number | null;
      created_at?: any | null;
      current_level?: number | null;
      current_streak?: number | null;
      current_xp?: number | null;
      downvote_count?: number | null;
      id: any;
      interaction_stats?: any | null;
      last_vote_date?: any | null;
      multipliers?: any | null;
      points?: number | null;
      points_breakdown?: any | null;
      titles?: any | null;
      today_vote_count?: number | null;
      total_reading_time?: number | null;
      total_votes?: number | null;
      updated_at?: any | null;
      upvote_count?: number | null;
      user_id: any;
      vote_accuracy?: any | null;
      xp_to_next_level?: number | null;
    }>;
  };
};

export type FetchOneUserMetricVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneUserMetricResponse = {
  __typename?: "query_root";
  user_metrics_by_pk?: {
    __typename?: "user_metrics";
    achievements?: any | null;
    best_streak?: number | null;
    created_at?: any | null;
    current_level?: number | null;
    current_streak?: number | null;
    current_xp?: number | null;
    downvote_count?: number | null;
    id: any;
    interaction_stats?: any | null;
    last_vote_date?: any | null;
    multipliers?: any | null;
    points?: number | null;
    points_breakdown?: any | null;
    titles?: any | null;
    today_vote_count?: number | null;
    total_reading_time?: number | null;
    total_votes?: number | null;
    updated_at?: any | null;
    upvote_count?: number | null;
    user_id: any;
    vote_accuracy?: any | null;
    xp_to_next_level?: number | null;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type FetchManyUserProfileVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<UserProfilesSelectColumn> | UserProfilesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<UserProfilesOrderBy> | UserProfilesOrderBy>;
  where?: InputMaybe<UserProfilesBoolExp>;
}>;

export type FetchManyUserProfileResponse = {
  __typename?: "query_root";
  user_profiles: Array<{
    __typename?: "user_profiles";
    avatar?: string | null;
    created_at?: any | null;
    dob?: any | null;
    email: string;
    followed_count?: number | null;
    followers_count?: number | null;
    gender_id?: any | null;
    given_name?: string | null;
    id: any;
    introduction?: string | null;
    is_active?: boolean | null;
    last_seen?: any | null;
    plan?: any | null;
    role: any;
    surname?: string | null;
    updated_at?: any | null;
    username?: string | null;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    comments: Array<{
      __typename?: "comments";
      content: string;
      content_id: any;
      content_type: any;
      created_at?: any | null;
      id: any;
      parent_comment_id?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    company_employees: Array<{
      __typename?: "company_employees";
      access_level: any;
      company_id?: any | null;
      created_at?: any | null;
      end_date?: any | null;
      id: any;
      job_description?: string | null;
      role: string;
      start_date?: any | null;
      status?: boolean | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    contacts: Array<{
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    content_source_visits: Array<{
      __typename?: "content_source_visits";
      content_id: any;
      created_at?: any | null;
      id: any;
      user_id?: any | null;
    }>;
    customer_payments: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
    customer_subscriptions: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    feedbacks: Array<{
      __typename?: "feedbacks";
      created_at: any;
      device_info?: string | null;
      feedback_status?: any | null;
      feedback_type?: any | null;
      id: number;
      message: string;
      page_identifier: string;
      rating?: number | null;
      resolution_comment?: string | null;
      updated_at: any;
      user_id?: any | null;
    }>;
    feeds: Array<{
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    }>;
    follows: Array<{
      __typename?: "follows";
      created_at?: any | null;
      followed_entity: any;
      followed_id: any;
      id: any;
      user_id: any;
    }>;
    user_metric?: {
      __typename?: "user_metrics";
      achievements?: any | null;
      best_streak?: number | null;
      created_at?: any | null;
      current_level?: number | null;
      current_streak?: number | null;
      current_xp?: number | null;
      downvote_count?: number | null;
      id: any;
      interaction_stats?: any | null;
      last_vote_date?: any | null;
      multipliers?: any | null;
      points?: number | null;
      points_breakdown?: any | null;
      titles?: any | null;
      today_vote_count?: number | null;
      total_reading_time?: number | null;
      total_votes?: number | null;
      updated_at?: any | null;
      upvote_count?: number | null;
      user_id: any;
      vote_accuracy?: any | null;
      xp_to_next_level?: number | null;
    } | null;
  }>;
};

export type CountUserProfileVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<UserProfilesSelectColumn> | UserProfilesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<UserProfilesOrderBy> | UserProfilesOrderBy>;
  where?: InputMaybe<UserProfilesBoolExp>;
}>;

export type CountUserProfileResponse = {
  __typename?: "query_root";
  user_profiles_aggregate: {
    __typename?: "user_profiles_aggregate";
    nodes: Array<{
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    }>;
  };
};

export type FetchOneUserProfileVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneUserProfileResponse = {
  __typename?: "query_root";
  user_profiles_by_pk?: {
    __typename?: "user_profiles";
    avatar?: string | null;
    created_at?: any | null;
    dob?: any | null;
    email: string;
    followed_count?: number | null;
    followers_count?: number | null;
    gender_id?: any | null;
    given_name?: string | null;
    id: any;
    introduction?: string | null;
    is_active?: boolean | null;
    last_seen?: any | null;
    plan?: any | null;
    role: any;
    surname?: string | null;
    updated_at?: any | null;
    username?: string | null;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    comments: Array<{
      __typename?: "comments";
      content: string;
      content_id: any;
      content_type: any;
      created_at?: any | null;
      id: any;
      parent_comment_id?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    company_employees: Array<{
      __typename?: "company_employees";
      access_level: any;
      company_id?: any | null;
      created_at?: any | null;
      end_date?: any | null;
      id: any;
      job_description?: string | null;
      role: string;
      start_date?: any | null;
      status?: boolean | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    contacts: Array<{
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    content_source_visits: Array<{
      __typename?: "content_source_visits";
      content_id: any;
      created_at?: any | null;
      id: any;
      user_id?: any | null;
    }>;
    customer_payments: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
    customer_subscriptions: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    feedbacks: Array<{
      __typename?: "feedbacks";
      created_at: any;
      device_info?: string | null;
      feedback_status?: any | null;
      feedback_type?: any | null;
      id: number;
      message: string;
      page_identifier: string;
      rating?: number | null;
      resolution_comment?: string | null;
      updated_at: any;
      user_id?: any | null;
    }>;
    feeds: Array<{
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    }>;
    follows: Array<{
      __typename?: "follows";
      created_at?: any | null;
      followed_entity: any;
      followed_id: any;
      id: any;
      user_id: any;
    }>;
    user_metric?: {
      __typename?: "user_metrics";
      achievements?: any | null;
      best_streak?: number | null;
      created_at?: any | null;
      current_level?: number | null;
      current_streak?: number | null;
      current_xp?: number | null;
      downvote_count?: number | null;
      id: any;
      interaction_stats?: any | null;
      last_vote_date?: any | null;
      multipliers?: any | null;
      points?: number | null;
      points_breakdown?: any | null;
      titles?: any | null;
      today_vote_count?: number | null;
      total_reading_time?: number | null;
      total_votes?: number | null;
      updated_at?: any | null;
      upvote_count?: number | null;
      user_id: any;
      vote_accuracy?: any | null;
      xp_to_next_level?: number | null;
    } | null;
  } | null;
};

export type FetchManyVoteVariables = Exact<{
  distinct_on?: InputMaybe<Array<VotesSelectColumn> | VotesSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<VotesOrderBy> | VotesOrderBy>;
  where?: InputMaybe<VotesBoolExp>;
}>;

export type FetchManyVoteResponse = {
  __typename?: "query_root";
  votes: Array<{
    __typename?: "votes";
    content_id: any;
    content_type: string;
    created_at?: any | null;
    id: any;
    user_id: any;
    vote_type: any;
  }>;
};

export type CountVoteVariables = Exact<{
  distinct_on?: InputMaybe<Array<VotesSelectColumn> | VotesSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<VotesOrderBy> | VotesOrderBy>;
  where?: InputMaybe<VotesBoolExp>;
}>;

export type CountVoteResponse = {
  __typename?: "query_root";
  votes_aggregate: {
    __typename?: "votes_aggregate";
    nodes: Array<{
      __typename?: "votes";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      id: any;
      user_id: any;
      vote_type: any;
    }>;
  };
};

export type FetchOneVoteVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneVoteResponse = {
  __typename?: "query_root";
  votes_by_pk?: {
    __typename?: "votes";
    content_id: any;
    content_type: string;
    created_at?: any | null;
    id: any;
    user_id: any;
    vote_type: any;
  } | null;
};

export type FetchManyWorkflowVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<WorkflowsSelectColumn> | WorkflowsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<WorkflowsOrderBy> | WorkflowsOrderBy>;
  where?: InputMaybe<WorkflowsBoolExp>;
}>;

export type FetchManyWorkflowResponse = {
  __typename?: "query_root";
  workflows: Array<{
    __typename?: "workflows";
    completed_at?: any | null;
    created_at?: any | null;
    id: any;
    metadata?: any | null;
    name: string;
    started_at?: any | null;
    status: any;
    updated_at?: any | null;
  }>;
};

export type CountWorkflowVariables = Exact<{
  distinct_on?: InputMaybe<
    Array<WorkflowsSelectColumn> | WorkflowsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<Array<WorkflowsOrderBy> | WorkflowsOrderBy>;
  where?: InputMaybe<WorkflowsBoolExp>;
}>;

export type CountWorkflowResponse = {
  __typename?: "query_root";
  workflows_aggregate: {
    __typename?: "workflows_aggregate";
    nodes: Array<{
      __typename?: "workflows";
      completed_at?: any | null;
      created_at?: any | null;
      id: any;
      metadata?: any | null;
      name: string;
      started_at?: any | null;
      status: any;
      updated_at?: any | null;
    }>;
  };
};

export type FetchOneWorkflowVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneWorkflowResponse = {
  __typename?: "query_root";
  workflows_by_pk?: {
    __typename?: "workflows";
    completed_at?: any | null;
    created_at?: any | null;
    id: any;
    metadata?: any | null;
    name: string;
    started_at?: any | null;
    status: any;
    updated_at?: any | null;
  } | null;
};

export type DeleteManyAdDailyMetricVariables = Exact<{
  where: AdDailyMetricsBoolExp;
}>;

export type DeleteManyAdDailyMetricResponse = {
  __typename?: "mutation_root";
  delete_ad_daily_metrics?: {
    __typename?: "ad_daily_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ad_daily_metrics";
      clicks?: number | null;
      created_at?: any | null;
      date: any;
      id: any;
      updated_at?: any | null;
      variant_id?: any | null;
      views?: number | null;
      ad_variant?: {
        __typename?: "ad_variants";
        active?: boolean | null;
        ad_id: any;
        content: any;
        created_at?: any | null;
        id: any;
        is_control?: boolean | null;
        performance_metrics?: any | null;
        updated_at?: any | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneAdDailyMetricVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneAdDailyMetricResponse = {
  __typename?: "mutation_root";
  delete_ad_daily_metrics_by_pk?: {
    __typename?: "ad_daily_metrics";
    clicks?: number | null;
    created_at?: any | null;
    date: any;
    id: any;
    updated_at?: any | null;
    variant_id?: any | null;
    views?: number | null;
    ad_variant?: {
      __typename?: "ad_variants";
      active?: boolean | null;
      ad_id: any;
      content: any;
      created_at?: any | null;
      id: any;
      is_control?: boolean | null;
      performance_metrics?: any | null;
      updated_at?: any | null;
    } | null;
  } | null;
};

export type DeleteManyAdPackageVariables = Exact<{
  where: AdPackagesBoolExp;
}>;

export type DeleteManyAdPackageResponse = {
  __typename?: "mutation_root";
  delete_ad_packages?: {
    __typename?: "ad_packages_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ad_packages";
      active?: boolean | null;
      avg_roi?: any | null;
      created_at?: any | null;
      description: string;
      expected_ctr?: any | null;
      features: Array<string>;
      id: any;
      name: string;
      position: string;
      price: any;
      updated_at?: any | null;
      view_frequency?: any | null;
      ads: Array<{
        __typename?: "ads";
        active?: boolean | null;
        company_id?: any | null;
        created_at?: any | null;
        end_date: any;
        id: any;
        package_id?: any | null;
        start_date: any;
        updated_at?: any | null;
      }>;
    }>;
  } | null;
};

export type DeleteOneAdPackageVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneAdPackageResponse = {
  __typename?: "mutation_root";
  delete_ad_packages_by_pk?: {
    __typename?: "ad_packages";
    active?: boolean | null;
    avg_roi?: any | null;
    created_at?: any | null;
    description: string;
    expected_ctr?: any | null;
    features: Array<string>;
    id: any;
    name: string;
    position: string;
    price: any;
    updated_at?: any | null;
    view_frequency?: any | null;
    ads: Array<{
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    }>;
  } | null;
};

export type DeleteManyAdVariantVariables = Exact<{
  where: AdVariantsBoolExp;
}>;

export type DeleteManyAdVariantResponse = {
  __typename?: "mutation_root";
  delete_ad_variants?: {
    __typename?: "ad_variants_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ad_variants";
      active?: boolean | null;
      ad_id: any;
      content: any;
      created_at?: any | null;
      id: any;
      is_control?: boolean | null;
      performance_metrics?: any | null;
      updated_at?: any | null;
      ad: {
        __typename?: "ads";
        active?: boolean | null;
        company_id?: any | null;
        created_at?: any | null;
        end_date: any;
        id: any;
        package_id?: any | null;
        start_date: any;
        updated_at?: any | null;
      };
      ad_daily_metrics: Array<{
        __typename?: "ad_daily_metrics";
        clicks?: number | null;
        created_at?: any | null;
        date: any;
        id: any;
        updated_at?: any | null;
        variant_id?: any | null;
        views?: number | null;
      }>;
    }>;
  } | null;
};

export type DeleteOneAdVariantVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneAdVariantResponse = {
  __typename?: "mutation_root";
  delete_ad_variants_by_pk?: {
    __typename?: "ad_variants";
    active?: boolean | null;
    ad_id: any;
    content: any;
    created_at?: any | null;
    id: any;
    is_control?: boolean | null;
    performance_metrics?: any | null;
    updated_at?: any | null;
    ad: {
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    };
    ad_daily_metrics: Array<{
      __typename?: "ad_daily_metrics";
      clicks?: number | null;
      created_at?: any | null;
      date: any;
      id: any;
      updated_at?: any | null;
      variant_id?: any | null;
      views?: number | null;
    }>;
  } | null;
};

export type DeleteManyAddressVariables = Exact<{
  where: AddressesBoolExp;
}>;

export type DeleteManyAddressResponse = {
  __typename?: "mutation_root";
  delete_addresses?: {
    __typename?: "addresses_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
      city: {
        __typename?: "cities";
        country_id: number;
        id: number;
        name: string;
        state?: string | null;
      };
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      country: {
        __typename?: "countries";
        code: string;
        code_3?: string | null;
        id: number;
        name: string;
      };
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneAddressVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneAddressResponse = {
  __typename?: "mutation_root";
  delete_addresses_by_pk?: {
    __typename?: "addresses";
    address_type?: any | null;
    city_id: number;
    company_id?: any | null;
    country_id: number;
    created_at?: any | null;
    id: number;
    is_primary?: boolean | null;
    name?: string | null;
    street1: string;
    street2?: string | null;
    updated_at?: any | null;
    user_id?: any | null;
    city: {
      __typename?: "cities";
      country_id: number;
      id: number;
      name: string;
      state?: string | null;
    };
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    country: {
      __typename?: "countries";
      code: string;
      code_3?: string | null;
      id: number;
      name: string;
    };
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type DeleteManyAdVariables = Exact<{
  where: AdsBoolExp;
}>;

export type DeleteManyAdResponse = {
  __typename?: "mutation_root";
  delete_ads?: {
    __typename?: "ads_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
      ad_package?: {
        __typename?: "ad_packages";
        active?: boolean | null;
        avg_roi?: any | null;
        created_at?: any | null;
        description: string;
        expected_ctr?: any | null;
        features: Array<string>;
        id: any;
        name: string;
        position: string;
        price: any;
        updated_at?: any | null;
        view_frequency?: any | null;
      } | null;
      ad_variants: Array<{
        __typename?: "ad_variants";
        active?: boolean | null;
        ad_id: any;
        content: any;
        created_at?: any | null;
        id: any;
        is_control?: boolean | null;
        performance_metrics?: any | null;
        updated_at?: any | null;
      }>;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null;
};

export type DeleteOneAdVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneAdResponse = {
  __typename?: "mutation_root";
  delete_ads_by_pk?: {
    __typename?: "ads";
    active?: boolean | null;
    company_id?: any | null;
    created_at?: any | null;
    end_date: any;
    id: any;
    package_id?: any | null;
    start_date: any;
    updated_at?: any | null;
    ad_package?: {
      __typename?: "ad_packages";
      active?: boolean | null;
      avg_roi?: any | null;
      created_at?: any | null;
      description: string;
      expected_ctr?: any | null;
      features: Array<string>;
      id: any;
      name: string;
      position: string;
      price: any;
      updated_at?: any | null;
      view_frequency?: any | null;
    } | null;
    ad_variants: Array<{
      __typename?: "ad_variants";
      active?: boolean | null;
      ad_id: any;
      content: any;
      created_at?: any | null;
      id: any;
      is_control?: boolean | null;
      performance_metrics?: any | null;
      updated_at?: any | null;
    }>;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type DeleteManyBlacklistedDomainVariables = Exact<{
  where: BlacklistedDomainsBoolExp;
}>;

export type DeleteManyBlacklistedDomainResponse = {
  __typename?: "mutation_root";
  delete_blacklisted_domains?: {
    __typename?: "blacklisted_domains_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "blacklisted_domains";
      created_at: any;
      id: any;
      reason?: string | null;
      url: string;
    }>;
  } | null;
};

export type DeleteOneBlacklistedDomainVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneBlacklistedDomainResponse = {
  __typename?: "mutation_root";
  delete_blacklisted_domains_by_pk?: {
    __typename?: "blacklisted_domains";
    created_at: any;
    id: any;
    reason?: string | null;
    url: string;
  } | null;
};

export type DeleteManyBlacklistedUrlVariables = Exact<{
  where: BlacklistedUrlsBoolExp;
}>;

export type DeleteManyBlacklistedUrlResponse = {
  __typename?: "mutation_root";
  delete_blacklisted_urls?: {
    __typename?: "blacklisted_urls_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "blacklisted_urls";
      company_id?: any | null;
      created_at?: any | null;
      id: number;
      reason?: string | null;
      url: string;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null;
};

export type DeleteOneBlacklistedUrlVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneBlacklistedUrlResponse = {
  __typename?: "mutation_root";
  delete_blacklisted_urls_by_pk?: {
    __typename?: "blacklisted_urls";
    company_id?: any | null;
    created_at?: any | null;
    id: number;
    reason?: string | null;
    url: string;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type DeleteManyBlockedIpVariables = Exact<{
  where: BlockedIpsBoolExp;
}>;

export type DeleteManyBlockedIpResponse = {
  __typename?: "mutation_root";
  delete_blocked_ips?: {
    __typename?: "blocked_ips_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "blocked_ips";
      blocked_at?: any | null;
      blocked_until: any;
      created_at?: any | null;
      failed_attempts?: number | null;
      id: any;
      ip_address: any;
      reason?: string | null;
      updated_at?: any | null;
    }>;
  } | null;
};

export type DeleteOneBlockedIpVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneBlockedIpResponse = {
  __typename?: "mutation_root";
  delete_blocked_ips_by_pk?: {
    __typename?: "blocked_ips";
    blocked_at?: any | null;
    blocked_until: any;
    created_at?: any | null;
    failed_attempts?: number | null;
    id: any;
    ip_address: any;
    reason?: string | null;
    updated_at?: any | null;
  } | null;
};

export type DeleteManyBookmarkFolderVariables = Exact<{
  where: BookmarkFoldersBoolExp;
}>;

export type DeleteManyBookmarkFolderResponse = {
  __typename?: "mutation_root";
  delete_bookmark_folders?: {
    __typename?: "bookmark_folders_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "bookmark_folders";
      color?: string | null;
      created_at?: any | null;
      id: any;
      is_default?: boolean | null;
      is_favorite?: boolean | null;
      name: string;
      parent_id?: any | null;
      path?: any | null;
      position?: number | null;
      updated_at?: any | null;
      user_id: any;
      bookmarks: Array<{
        __typename?: "bookmarks";
        content_id: any;
        content_type: string;
        created_at?: any | null;
        folder_id?: any | null;
        id: any;
        metadata?: any | null;
        updated_at?: any | null;
        user_id: any;
      }>;
    }>;
  } | null;
};

export type DeleteOneBookmarkFolderVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneBookmarkFolderResponse = {
  __typename?: "mutation_root";
  delete_bookmark_folders_by_pk?: {
    __typename?: "bookmark_folders";
    color?: string | null;
    created_at?: any | null;
    id: any;
    is_default?: boolean | null;
    is_favorite?: boolean | null;
    name: string;
    parent_id?: any | null;
    path?: any | null;
    position?: number | null;
    updated_at?: any | null;
    user_id: any;
    bookmarks: Array<{
      __typename?: "bookmarks";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      folder_id?: any | null;
      id: any;
      metadata?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  } | null;
};

export type DeleteManyBookmarkVariables = Exact<{
  where: BookmarksBoolExp;
}>;

export type DeleteManyBookmarkResponse = {
  __typename?: "mutation_root";
  delete_bookmarks?: {
    __typename?: "bookmarks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "bookmarks";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      folder_id?: any | null;
      id: any;
      metadata?: any | null;
      updated_at?: any | null;
      user_id: any;
      bookmark_folder?: {
        __typename?: "bookmark_folders";
        color?: string | null;
        created_at?: any | null;
        id: any;
        is_default?: boolean | null;
        is_favorite?: boolean | null;
        name: string;
        parent_id?: any | null;
        path?: any | null;
        position?: number | null;
        updated_at?: any | null;
        user_id: any;
      } | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null;
};

export type DeleteOneBookmarkVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneBookmarkResponse = {
  __typename?: "mutation_root";
  delete_bookmarks_by_pk?: {
    __typename?: "bookmarks";
    content_id: any;
    content_type: string;
    created_at?: any | null;
    folder_id?: any | null;
    id: any;
    metadata?: any | null;
    updated_at?: any | null;
    user_id: any;
    bookmark_folder?: {
      __typename?: "bookmark_folders";
      color?: string | null;
      created_at?: any | null;
      id: any;
      is_default?: boolean | null;
      is_favorite?: boolean | null;
      name: string;
      parent_id?: any | null;
      path?: any | null;
      position?: number | null;
      updated_at?: any | null;
      user_id: any;
    } | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type DeleteManyBusinessDomainVariables = Exact<{
  where: BusinessDomainsBoolExp;
}>;

export type DeleteManyBusinessDomainResponse = {
  __typename?: "mutation_root";
  delete_business_domains?: {
    __typename?: "business_domains_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "business_domains";
      created_at?: any | null;
      description?: string | null;
      id: any;
      name: string;
      parent_id?: any | null;
      slug: string;
      updated_at?: any | null;
      categorized_urls: Array<{
        __typename?: "categorized_urls";
        categorizer_version: string;
        company_id?: any | null;
        confidence: any;
        content_hash?: string | null;
        created_at?: any | null;
        domain_id: any;
        found_on?: string | null;
        id: any;
        priority?: any | null;
        updated_at?: any | null;
        url: string;
      }>;
    }>;
  } | null;
};

export type DeleteOneBusinessDomainVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneBusinessDomainResponse = {
  __typename?: "mutation_root";
  delete_business_domains_by_pk?: {
    __typename?: "business_domains";
    created_at?: any | null;
    description?: string | null;
    id: any;
    name: string;
    parent_id?: any | null;
    slug: string;
    updated_at?: any | null;
    categorized_urls: Array<{
      __typename?: "categorized_urls";
      categorizer_version: string;
      company_id?: any | null;
      confidence: any;
      content_hash?: string | null;
      created_at?: any | null;
      domain_id: any;
      found_on?: string | null;
      id: any;
      priority?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
  } | null;
};

export type DeleteManyCategoryVariables = Exact<{
  where: CategoriesBoolExp;
}>;

export type DeleteManyCategoryResponse = {
  __typename?: "mutation_root";
  delete_categories?: {
    __typename?: "categories_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
      companies: Array<{
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      }>;
      content_categories: Array<{
        __typename?: "content_categories";
        category_id: any;
        content_id: any;
        is_primary: boolean;
      }>;
      feed_categories: Array<{
        __typename?: "feed_categories";
        category_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      news: Array<{
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      }>;
    }>;
  } | null;
};

export type DeleteOneCategoryVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneCategoryResponse = {
  __typename?: "mutation_root";
  delete_categories_by_pk?: {
    __typename?: "categories";
    body?: string | null;
    created_at: any;
    document_id?: string | null;
    id: any;
    locale?: string | null;
    name: string;
    published_at?: string | null;
    updated_at?: any | null;
    companies: Array<{
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    }>;
    content_categories: Array<{
      __typename?: "content_categories";
      category_id: any;
      content_id: any;
      is_primary: boolean;
    }>;
    feed_categories: Array<{
      __typename?: "feed_categories";
      category_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    news: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
  } | null;
};

export type DeleteManyCategorizedUrlVariables = Exact<{
  where: CategorizedUrlsBoolExp;
}>;

export type DeleteManyCategorizedUrlResponse = {
  __typename?: "mutation_root";
  delete_categorized_urls?: {
    __typename?: "categorized_urls_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "categorized_urls";
      categorizer_version: string;
      company_id?: any | null;
      confidence: any;
      content_hash?: string | null;
      created_at?: any | null;
      domain_id: any;
      found_on?: string | null;
      id: any;
      priority?: any | null;
      updated_at?: any | null;
      url: string;
      business_domain: {
        __typename?: "business_domains";
        created_at?: any | null;
        description?: string | null;
        id: any;
        name: string;
        parent_id?: any | null;
        slug: string;
        updated_at?: any | null;
      };
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null;
};

export type DeleteOneCategorizedUrlVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneCategorizedUrlResponse = {
  __typename?: "mutation_root";
  delete_categorized_urls_by_pk?: {
    __typename?: "categorized_urls";
    categorizer_version: string;
    company_id?: any | null;
    confidence: any;
    content_hash?: string | null;
    created_at?: any | null;
    domain_id: any;
    found_on?: string | null;
    id: any;
    priority?: any | null;
    updated_at?: any | null;
    url: string;
    business_domain: {
      __typename?: "business_domains";
      created_at?: any | null;
      description?: string | null;
      id: any;
      name: string;
      parent_id?: any | null;
      slug: string;
      updated_at?: any | null;
    };
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type DeleteManyCircuitBreakerStateVariables = Exact<{
  where: CircuitBreakerStatesBoolExp;
}>;

export type DeleteManyCircuitBreakerStateResponse = {
  __typename?: "mutation_root";
  delete_circuit_breaker_states?: {
    __typename?: "circuit_breaker_states_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "circuit_breaker_states";
      created_at?: any | null;
      failure_count?: number | null;
      id: any;
      job_name: string;
      last_failure?: any | null;
      last_success?: any | null;
      state: string;
      updated_at?: any | null;
    }>;
  } | null;
};

export type DeleteOneCircuitBreakerStateVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneCircuitBreakerStateResponse = {
  __typename?: "mutation_root";
  delete_circuit_breaker_states_by_pk?: {
    __typename?: "circuit_breaker_states";
    created_at?: any | null;
    failure_count?: number | null;
    id: any;
    job_name: string;
    last_failure?: any | null;
    last_success?: any | null;
    state: string;
    updated_at?: any | null;
  } | null;
};

export type DeleteManyCityVariables = Exact<{
  where: CitiesBoolExp;
}>;

export type DeleteManyCityResponse = {
  __typename?: "mutation_root";
  delete_cities?: {
    __typename?: "cities_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "cities";
      country_id: number;
      id: number;
      name: string;
      state?: string | null;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      country: {
        __typename?: "countries";
        code: string;
        code_3?: string | null;
        id: number;
        name: string;
      };
    }>;
  } | null;
};

export type DeleteOneCityVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCityResponse = {
  __typename?: "mutation_root";
  delete_cities_by_pk?: {
    __typename?: "cities";
    country_id: number;
    id: number;
    name: string;
    state?: string | null;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    country: {
      __typename?: "countries";
      code: string;
      code_3?: string | null;
      id: number;
      name: string;
    };
  } | null;
};

export type DeleteManyCommentVariables = Exact<{
  where: CommentsBoolExp;
}>;

export type DeleteManyCommentResponse = {
  __typename?: "mutation_root";
  delete_comments?: {
    __typename?: "comments_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "comments";
      content: string;
      content_id: any;
      content_type: any;
      created_at?: any | null;
      id: any;
      parent_comment_id?: any | null;
      updated_at?: any | null;
      user_id: any;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneCommentVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneCommentResponse = {
  __typename?: "mutation_root";
  delete_comments_by_pk?: {
    __typename?: "comments";
    content: string;
    content_id: any;
    content_type: any;
    created_at?: any | null;
    id: any;
    parent_comment_id?: any | null;
    updated_at?: any | null;
    user_id: any;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type DeleteManyCompanyVariables = Exact<{
  where: CompaniesBoolExp;
}>;

export type DeleteManyCompanyResponse = {
  __typename?: "mutation_root";
  delete_companies?: {
    __typename?: "companies_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      ads: Array<{
        __typename?: "ads";
        active?: boolean | null;
        company_id?: any | null;
        created_at?: any | null;
        end_date: any;
        id: any;
        package_id?: any | null;
        start_date: any;
        updated_at?: any | null;
      }>;
      blacklisted_urls: Array<{
        __typename?: "blacklisted_urls";
        company_id?: any | null;
        created_at?: any | null;
        id: number;
        reason?: string | null;
        url: string;
      }>;
      categorized_urls: Array<{
        __typename?: "categorized_urls";
        categorizer_version: string;
        company_id?: any | null;
        confidence: any;
        content_hash?: string | null;
        created_at?: any | null;
        domain_id: any;
        found_on?: string | null;
        id: any;
        priority?: any | null;
        updated_at?: any | null;
        url: string;
      }>;
      categoryByCategoryId?: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      } | null;
      company_contacts: Array<{
        __typename?: "company_contacts";
        company_id?: any | null;
        contact_id: number;
        created_at: any;
        id: number;
        updated_at: any;
      }>;
      company_extras: Array<{
        __typename?: "company_extras";
        body?: string | null;
        category: string;
        company_id?: any | null;
        created_at: any;
        found_count?: number | null;
        id: number;
        level: any;
        review?: any | null;
        success?: boolean | null;
        updated_at: any;
        url: string;
      }>;
      contacts: Array<{
        __typename?: "contacts";
        company_id?: any | null;
        contact_type?: any | null;
        created_at?: any | null;
        email?: string | null;
        id: number;
        is_primary?: boolean | null;
        phone?: string | null;
        privacy_level?: any | null;
        title?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      content_sources: Array<{
        __typename?: "content_sources";
        company_id?: any | null;
        content_type: any;
        created_at?: any | null;
        expected_count?: any | null;
        failed_count?: any | null;
        has_failed?: boolean | null;
        hash?: any | null;
        id: any;
        priority: any;
        refreshed_at?: any | null;
        rss_urls?: Array<string> | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        updated_at?: any | null;
        url: string;
      }>;
      news: Array<{
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      }>;
      social_medium?: {
        __typename?: "social_media";
        created_at?: any | null;
        facebook_url?: string | null;
        id: number;
        instagram_url?: string | null;
        linkedin_url?: string | null;
        twitter_url?: string | null;
        updated_at?: any | null;
        youtube_url?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneCompanyVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneCompanyResponse = {
  __typename?: "mutation_root";
  delete_companies_by_pk?: {
    __typename?: "companies";
    category?: string | null;
    category_id?: any | null;
    content_status: any;
    created_at?: any | null;
    description?: string | null;
    failed_count?: any | null;
    founding_year?: any | null;
    id: any;
    is_english?: boolean | null;
    is_government?: boolean | null;
    keywords?: any | null;
    logo_url?: string | null;
    name?: string | null;
    scrape_frequency?: any | null;
    scrape_rating?: any | null;
    scraped_at?: any | null;
    social_media_id?: number | null;
    updated_at?: any | null;
    url: string;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    ads: Array<{
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    }>;
    blacklisted_urls: Array<{
      __typename?: "blacklisted_urls";
      company_id?: any | null;
      created_at?: any | null;
      id: number;
      reason?: string | null;
      url: string;
    }>;
    categorized_urls: Array<{
      __typename?: "categorized_urls";
      categorizer_version: string;
      company_id?: any | null;
      confidence: any;
      content_hash?: string | null;
      created_at?: any | null;
      domain_id: any;
      found_on?: string | null;
      id: any;
      priority?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
    categoryByCategoryId?: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    } | null;
    company_contacts: Array<{
      __typename?: "company_contacts";
      company_id?: any | null;
      contact_id: number;
      created_at: any;
      id: number;
      updated_at: any;
    }>;
    company_extras: Array<{
      __typename?: "company_extras";
      body?: string | null;
      category: string;
      company_id?: any | null;
      created_at: any;
      found_count?: number | null;
      id: number;
      level: any;
      review?: any | null;
      success?: boolean | null;
      updated_at: any;
      url: string;
    }>;
    contacts: Array<{
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    content_sources: Array<{
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
    news: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
    social_medium?: {
      __typename?: "social_media";
      created_at?: any | null;
      facebook_url?: string | null;
      id: number;
      instagram_url?: string | null;
      linkedin_url?: string | null;
      twitter_url?: string | null;
      updated_at?: any | null;
      youtube_url?: string | null;
    } | null;
  } | null;
};

export type DeleteManyCompanyContactVariables = Exact<{
  where: CompanyContactsBoolExp;
}>;

export type DeleteManyCompanyContactResponse = {
  __typename?: "mutation_root";
  delete_company_contacts?: {
    __typename?: "company_contacts_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_contacts";
      company_id?: any | null;
      contact_id: number;
      created_at: any;
      id: number;
      updated_at: any;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      contact: {
        __typename?: "contacts";
        company_id?: any | null;
        contact_type?: any | null;
        created_at?: any | null;
        email?: string | null;
        id: number;
        is_primary?: boolean | null;
        phone?: string | null;
        privacy_level?: any | null;
        title?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      };
    }>;
  } | null;
};

export type DeleteOneCompanyContactVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCompanyContactResponse = {
  __typename?: "mutation_root";
  delete_company_contacts_by_pk?: {
    __typename?: "company_contacts";
    company_id?: any | null;
    contact_id: number;
    created_at: any;
    id: number;
    updated_at: any;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    contact: {
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    };
  } | null;
};

export type DeleteManyCompanyEmployeeVariables = Exact<{
  where: CompanyEmployeesBoolExp;
}>;

export type DeleteManyCompanyEmployeeResponse = {
  __typename?: "mutation_root";
  delete_company_employees?: {
    __typename?: "company_employees_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_employees";
      access_level: any;
      company_id?: any | null;
      created_at?: any | null;
      end_date?: any | null;
      id: any;
      job_description?: string | null;
      role: string;
      start_date?: any | null;
      status?: boolean | null;
      updated_at?: any | null;
      user_id: any;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneCompanyEmployeeVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneCompanyEmployeeResponse = {
  __typename?: "mutation_root";
  delete_company_employees_by_pk?: {
    __typename?: "company_employees";
    access_level: any;
    company_id?: any | null;
    created_at?: any | null;
    end_date?: any | null;
    id: any;
    job_description?: string | null;
    role: string;
    start_date?: any | null;
    status?: boolean | null;
    updated_at?: any | null;
    user_id: any;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type DeleteManyCompanyExtraVariables = Exact<{
  where: CompanyExtrasBoolExp;
}>;

export type DeleteManyCompanyExtraResponse = {
  __typename?: "mutation_root";
  delete_company_extras?: {
    __typename?: "company_extras_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_extras";
      body?: string | null;
      category: string;
      company_id?: any | null;
      created_at: any;
      found_count?: number | null;
      id: number;
      level: any;
      review?: any | null;
      success?: boolean | null;
      updated_at: any;
      url: string;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null;
};

export type DeleteOneCompanyExtraVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCompanyExtraResponse = {
  __typename?: "mutation_root";
  delete_company_extras_by_pk?: {
    __typename?: "company_extras";
    body?: string | null;
    category: string;
    company_id?: any | null;
    created_at: any;
    found_count?: number | null;
    id: number;
    level: any;
    review?: any | null;
    success?: boolean | null;
    updated_at: any;
    url: string;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type DeleteManyCompanyMetricVariables = Exact<{
  where: CompanyMetricsBoolExp;
}>;

export type DeleteManyCompanyMetricResponse = {
  __typename?: "mutation_root";
  delete_company_metrics?: {
    __typename?: "company_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_metrics";
      company_id: any;
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
      metric_definition?: {
        __typename?: "metric_definitions";
        category?: string | null;
        description?: string | null;
        id: number;
        is_dimensional?: boolean | null;
        name: string;
        type: string;
        unit?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneCompanyMetricVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneCompanyMetricResponse = {
  __typename?: "mutation_root";
  delete_company_metrics_by_pk?: {
    __typename?: "company_metrics";
    company_id: any;
    crawl_id: any;
    id: any;
    metric_id?: number | null;
    timestamp: any;
    value: any;
    metric_definition?: {
      __typename?: "metric_definitions";
      category?: string | null;
      description?: string | null;
      id: number;
      is_dimensional?: boolean | null;
      name: string;
      type: string;
      unit?: string | null;
    } | null;
  } | null;
};

export type DeleteManyContactVariables = Exact<{
  where: ContactsBoolExp;
}>;

export type DeleteManyContactResponse = {
  __typename?: "mutation_root";
  delete_contacts?: {
    __typename?: "contacts_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      company_contacts: Array<{
        __typename?: "company_contacts";
        company_id?: any | null;
        contact_id: number;
        created_at: any;
        id: number;
        updated_at: any;
      }>;
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneContactVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneContactResponse = {
  __typename?: "mutation_root";
  delete_contacts_by_pk?: {
    __typename?: "contacts";
    company_id?: any | null;
    contact_type?: any | null;
    created_at?: any | null;
    email?: string | null;
    id: number;
    is_primary?: boolean | null;
    phone?: string | null;
    privacy_level?: any | null;
    title?: string | null;
    updated_at?: any | null;
    user_id?: any | null;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    company_contacts: Array<{
      __typename?: "company_contacts";
      company_id?: any | null;
      contact_id: number;
      created_at: any;
      id: number;
      updated_at: any;
    }>;
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type DeleteManyContentCategoryVariables = Exact<{
  where: ContentCategoriesBoolExp;
}>;

export type DeleteManyContentCategoryResponse = {
  __typename?: "mutation_root";
  delete_content_categories?: {
    __typename?: "content_categories_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_categories";
      category_id: any;
      content_id: any;
      is_primary: boolean;
      category: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      };
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null;
};

export type DeleteOneContentCategoryVariables = Exact<{
  category_id: Scalars["bigint"]["input"];
  content_id: Scalars["uuid"]["input"];
}>;

export type DeleteOneContentCategoryResponse = {
  __typename?: "mutation_root";
  delete_content_categories_by_pk?: {
    __typename?: "content_categories";
    category_id: any;
    content_id: any;
    is_primary: boolean;
    category: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    };
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type DeleteManyContentSourceVisitVariables = Exact<{
  where: ContentSourceVisitsBoolExp;
}>;

export type DeleteManyContentSourceVisitResponse = {
  __typename?: "mutation_root";
  delete_content_source_visits?: {
    __typename?: "content_source_visits_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_source_visits";
      content_id: any;
      created_at?: any | null;
      id: any;
      user_id?: any | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneContentSourceVisitVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneContentSourceVisitResponse = {
  __typename?: "mutation_root";
  delete_content_source_visits_by_pk?: {
    __typename?: "content_source_visits";
    content_id: any;
    created_at?: any | null;
    id: any;
    user_id?: any | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type DeleteManyContentSourceVariables = Exact<{
  where: ContentSourcesBoolExp;
}>;

export type DeleteManyContentSourceResponse = {
  __typename?: "mutation_root";
  delete_content_sources?: {
    __typename?: "content_sources_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      feed_sources: Array<{
        __typename?: "feed_sources";
        content_source_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      news: Array<{
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      }>;
    }>;
  } | null;
};

export type DeleteOneContentSourceVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneContentSourceResponse = {
  __typename?: "mutation_root";
  delete_content_sources_by_pk?: {
    __typename?: "content_sources";
    company_id?: any | null;
    content_type: any;
    created_at?: any | null;
    expected_count?: any | null;
    failed_count?: any | null;
    has_failed?: boolean | null;
    hash?: any | null;
    id: any;
    priority: any;
    refreshed_at?: any | null;
    rss_urls?: Array<string> | null;
    scrape_frequency: any;
    scraped_at?: any | null;
    updated_at?: any | null;
    url: string;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    feed_sources: Array<{
      __typename?: "feed_sources";
      content_source_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    news: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
  } | null;
};

export type DeleteManyContentStatusVariables = Exact<{
  where: ContentStatusesBoolExp;
}>;

export type DeleteManyContentStatusResponse = {
  __typename?: "mutation_root";
  delete_content_statuses?: {
    __typename?: "content_statuses_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_statuses";
      content_id: any;
      content_status: any;
      created_at?: any | null;
      id: any;
      notes?: string | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null;
};

export type DeleteOneContentStatusVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneContentStatusResponse = {
  __typename?: "mutation_root";
  delete_content_statuses_by_pk?: {
    __typename?: "content_statuses";
    content_id: any;
    content_status: any;
    created_at?: any | null;
    id: any;
    notes?: string | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type DeleteManyContentTagVariables = Exact<{
  where: ContentTagsBoolExp;
}>;

export type DeleteManyContentTagResponse = {
  __typename?: "mutation_root";
  delete_content_tags?: {
    __typename?: "content_tags_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_tags";
      content_id: any;
      tag_id: number;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      tag: {
        __typename?: "tags";
        body?: string | null;
        created_at?: any | null;
        document_id?: string | null;
        id: number;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      };
    }>;
  } | null;
};

export type DeleteOneContentTagVariables = Exact<{
  content_id: Scalars["uuid"]["input"];
  tag_id: Scalars["Int"]["input"];
}>;

export type DeleteOneContentTagResponse = {
  __typename?: "mutation_root";
  delete_content_tags_by_pk?: {
    __typename?: "content_tags";
    content_id: any;
    tag_id: number;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    tag: {
      __typename?: "tags";
      body?: string | null;
      created_at?: any | null;
      document_id?: string | null;
      id: number;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    };
  } | null;
};

export type DeleteManyContentVariables = Exact<{
  where: ContentsBoolExp;
}>;

export type DeleteManyContentResponse = {
  __typename?: "mutation_root";
  delete_contents?: {
    __typename?: "contents_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
      bookmarks: Array<{
        __typename?: "bookmarks";
        content_id: any;
        content_type: string;
        created_at?: any | null;
        folder_id?: any | null;
        id: any;
        metadata?: any | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      content_categories: Array<{
        __typename?: "content_categories";
        category_id: any;
        content_id: any;
        is_primary: boolean;
      }>;
      content_source_visits: Array<{
        __typename?: "content_source_visits";
        content_id: any;
        created_at?: any | null;
        id: any;
        user_id?: any | null;
      }>;
      content_statuses: Array<{
        __typename?: "content_statuses";
        content_id: any;
        content_status: any;
        created_at?: any | null;
        id: any;
        notes?: string | null;
      }>;
      content_tags: Array<{
        __typename?: "content_tags";
        content_id: any;
        tag_id: number;
      }>;
      news?: {
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      } | null;
      newsletter?: {
        __typename?: "newsletters";
        content_status: any;
        created_at?: any | null;
        end_date: any;
        frequency: string;
        generated_content?: string | null;
        id: any;
        start_date: any;
        title: string;
        updated_at?: any | null;
      } | null;
      research?: {
        __typename?: "research";
        abstract?: string | null;
        abstract_url: string;
        affiliations?: any | null;
        authors?: any | null;
        category?: string | null;
        comments?: string | null;
        content_status: any;
        created_at: any;
        doi_url?: string | null;
        figure_count?: any | null;
        has_embedding?: boolean | null;
        id: any;
        is_flagged: boolean;
        keywords?: string | null;
        month?: string | null;
        page_count?: any | null;
        pdf_url?: string | null;
        published_at?: any | null;
        published_in?: string | null;
        summary?: string | null;
        table_count?: any | null;
        title?: string | null;
        updated_at?: any | null;
        version?: any | null;
        year?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneContentVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneContentResponse = {
  __typename?: "mutation_root";
  delete_contents_by_pk?: {
    __typename?: "contents";
    content_type: any;
    created_at?: any | null;
    hot_score?: any | null;
    id: any;
    rss_url?: string | null;
    title?: string | null;
    updated_at?: any | null;
    url: string;
    bookmarks: Array<{
      __typename?: "bookmarks";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      folder_id?: any | null;
      id: any;
      metadata?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    content_categories: Array<{
      __typename?: "content_categories";
      category_id: any;
      content_id: any;
      is_primary: boolean;
    }>;
    content_source_visits: Array<{
      __typename?: "content_source_visits";
      content_id: any;
      created_at?: any | null;
      id: any;
      user_id?: any | null;
    }>;
    content_statuses: Array<{
      __typename?: "content_statuses";
      content_id: any;
      content_status: any;
      created_at?: any | null;
      id: any;
      notes?: string | null;
    }>;
    content_tags: Array<{
      __typename?: "content_tags";
      content_id: any;
      tag_id: number;
    }>;
    news?: {
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    } | null;
    newsletter?: {
      __typename?: "newsletters";
      content_status: any;
      created_at?: any | null;
      end_date: any;
      frequency: string;
      generated_content?: string | null;
      id: any;
      start_date: any;
      title: string;
      updated_at?: any | null;
    } | null;
    research?: {
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
    } | null;
  } | null;
};

export type DeleteManyCountryVariables = Exact<{
  where: CountriesBoolExp;
}>;

export type DeleteManyCountryResponse = {
  __typename?: "mutation_root";
  delete_countries?: {
    __typename?: "countries_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "countries";
      code: string;
      code_3?: string | null;
      id: number;
      name: string;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      cities: Array<{
        __typename?: "cities";
        country_id: number;
        id: number;
        name: string;
        state?: string | null;
      }>;
    }>;
  } | null;
};

export type DeleteOneCountryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCountryResponse = {
  __typename?: "mutation_root";
  delete_countries_by_pk?: {
    __typename?: "countries";
    code: string;
    code_3?: string | null;
    id: number;
    name: string;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    cities: Array<{
      __typename?: "cities";
      country_id: number;
      id: number;
      name: string;
      state?: string | null;
    }>;
  } | null;
};

export type DeleteManyCustomerPaymentVariables = Exact<{
  where: CustomerPaymentsBoolExp;
}>;

export type DeleteManyCustomerPaymentResponse = {
  __typename?: "mutation_root";
  delete_customer_payments?: {
    __typename?: "customer_payments_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
      customer_refunds: Array<{
        __typename?: "customer_refunds";
        acquirer_data?: any | null;
        amount: any;
        batch_id?: string | null;
        created_at?: any | null;
        currency?: string | null;
        external_refund_id: string;
        id: number;
        notes?: any | null;
        payment_id: number;
        receipt?: string | null;
        speed_processed?: string | null;
        speed_requested?: string | null;
        status: string;
      }>;
      customer_subscription?: {
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      } | null;
      payment_provider: {
        __typename?: "payment_providers";
        created_at?: any | null;
        id: number;
        is_active?: boolean | null;
        name: string;
        updated_at?: any | null;
      };
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneCustomerPaymentVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCustomerPaymentResponse = {
  __typename?: "mutation_root";
  delete_customer_payments_by_pk?: {
    __typename?: "customer_payments";
    acquirer_data?: any | null;
    amount: any;
    amount_refunded?: any | null;
    amount_transferred?: any | null;
    bank?: string | null;
    captured?: boolean | null;
    created_at?: any | null;
    currency: string;
    description?: string | null;
    error_code?: string | null;
    error_description?: string | null;
    error_reason?: string | null;
    error_source?: string | null;
    error_step?: string | null;
    external_order_id?: string | null;
    external_payment_id: string;
    fee?: any | null;
    id: number;
    international?: boolean | null;
    invoice_id?: string | null;
    method?: string | null;
    notes?: any | null;
    order_id?: string | null;
    payment_provider_id: number;
    refund_status?: string | null;
    status: string;
    subscription_id?: number | null;
    tax?: any | null;
    user_id: any;
    vpa?: string | null;
    wallet?: string | null;
    customer_refunds: Array<{
      __typename?: "customer_refunds";
      acquirer_data?: any | null;
      amount: any;
      batch_id?: string | null;
      created_at?: any | null;
      currency?: string | null;
      external_refund_id: string;
      id: number;
      notes?: any | null;
      payment_id: number;
      receipt?: string | null;
      speed_processed?: string | null;
      speed_requested?: string | null;
      status: string;
    }>;
    customer_subscription?: {
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    } | null;
    payment_provider: {
      __typename?: "payment_providers";
      created_at?: any | null;
      id: number;
      is_active?: boolean | null;
      name: string;
      updated_at?: any | null;
    };
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type DeleteManyCustomerProcessedWebhookVariables = Exact<{
  where: CustomerProcessedWebhooksBoolExp;
}>;

export type DeleteManyCustomerProcessedWebhookResponse = {
  __typename?: "mutation_root";
  delete_customer_processed_webhooks?: {
    __typename?: "customer_processed_webhooks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_processed_webhooks";
      event_id: string;
      event_type: string;
      id: number;
      processed_at: any;
    }>;
  } | null;
};

export type DeleteOneCustomerProcessedWebhookVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCustomerProcessedWebhookResponse = {
  __typename?: "mutation_root";
  delete_customer_processed_webhooks_by_pk?: {
    __typename?: "customer_processed_webhooks";
    event_id: string;
    event_type: string;
    id: number;
    processed_at: any;
  } | null;
};

export type DeleteManyCustomerRefundVariables = Exact<{
  where: CustomerRefundsBoolExp;
}>;

export type DeleteManyCustomerRefundResponse = {
  __typename?: "mutation_root";
  delete_customer_refunds?: {
    __typename?: "customer_refunds_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_refunds";
      acquirer_data?: any | null;
      amount: any;
      batch_id?: string | null;
      created_at?: any | null;
      currency?: string | null;
      external_refund_id: string;
      id: number;
      notes?: any | null;
      payment_id: number;
      receipt?: string | null;
      speed_processed?: string | null;
      speed_requested?: string | null;
      status: string;
      customer_payment: {
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneCustomerRefundVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCustomerRefundResponse = {
  __typename?: "mutation_root";
  delete_customer_refunds_by_pk?: {
    __typename?: "customer_refunds";
    acquirer_data?: any | null;
    amount: any;
    batch_id?: string | null;
    created_at?: any | null;
    currency?: string | null;
    external_refund_id: string;
    id: number;
    notes?: any | null;
    payment_id: number;
    receipt?: string | null;
    speed_processed?: string | null;
    speed_requested?: string | null;
    status: string;
    customer_payment: {
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    };
  } | null;
};

export type DeleteManyCustomerSubscriptionPlanVariables = Exact<{
  where: CustomerSubscriptionPlansBoolExp;
}>;

export type DeleteManyCustomerSubscriptionPlanResponse = {
  __typename?: "mutation_root";
  delete_customer_subscription_plans?: {
    __typename?: "customer_subscription_plans_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_subscription_plans";
      annual_amount: any;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      external_plan_id?: string | null;
      features?: any | null;
      id: number;
      interval: number;
      interval_type: string;
      is_active?: boolean | null;
      monthly_amount: any;
      name: string;
      updated_at?: any | null;
      customer_subscriptions: Array<{
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      }>;
    }>;
  } | null;
};

export type DeleteOneCustomerSubscriptionPlanVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCustomerSubscriptionPlanResponse = {
  __typename?: "mutation_root";
  delete_customer_subscription_plans_by_pk?: {
    __typename?: "customer_subscription_plans";
    annual_amount: any;
    created_at?: any | null;
    currency: string;
    description?: string | null;
    external_plan_id?: string | null;
    features?: any | null;
    id: number;
    interval: number;
    interval_type: string;
    is_active?: boolean | null;
    monthly_amount: any;
    name: string;
    updated_at?: any | null;
    customer_subscriptions: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  } | null;
};

export type DeleteManyCustomerSubscriptionVariables = Exact<{
  where: CustomerSubscriptionsBoolExp;
}>;

export type DeleteManyCustomerSubscriptionResponse = {
  __typename?: "mutation_root";
  delete_customer_subscriptions?: {
    __typename?: "customer_subscriptions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
      customer_payments: Array<{
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      }>;
      customer_subscription_plan: {
        __typename?: "customer_subscription_plans";
        annual_amount: any;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        external_plan_id?: string | null;
        features?: any | null;
        id: number;
        interval: number;
        interval_type: string;
        is_active?: boolean | null;
        monthly_amount: any;
        name: string;
        updated_at?: any | null;
      };
      payment_provider: {
        __typename?: "payment_providers";
        created_at?: any | null;
        id: number;
        is_active?: boolean | null;
        name: string;
        updated_at?: any | null;
      };
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneCustomerSubscriptionVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCustomerSubscriptionResponse = {
  __typename?: "mutation_root";
  delete_customer_subscriptions_by_pk?: {
    __typename?: "customer_subscriptions";
    auth_attempts?: number | null;
    cancel_at_period_end?: boolean | null;
    cancel_initiated_by?: string | null;
    change_scheduled_at?: any | null;
    charge_at?: any | null;
    created_at?: any | null;
    current_end: any;
    current_start: any;
    customer_notify?: boolean | null;
    end_at?: any | null;
    ended_at?: any | null;
    expire_by?: any | null;
    external_subscription_id: string;
    has_scheduled_changes?: boolean | null;
    id: number;
    notes?: any | null;
    offer_id?: string | null;
    paid_count?: number | null;
    pause_initiated_by?: string | null;
    payment_provider_id: number;
    plan_id: number;
    quantity?: number | null;
    remaining_count?: number | null;
    short_url?: string | null;
    source?: string | null;
    start_at?: any | null;
    status: string;
    total_count?: number | null;
    type?: number | null;
    updated_at?: any | null;
    user_id: any;
    customer_payments: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
    customer_subscription_plan: {
      __typename?: "customer_subscription_plans";
      annual_amount: any;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      external_plan_id?: string | null;
      features?: any | null;
      id: number;
      interval: number;
      interval_type: string;
      is_active?: boolean | null;
      monthly_amount: any;
      name: string;
      updated_at?: any | null;
    };
    payment_provider: {
      __typename?: "payment_providers";
      created_at?: any | null;
      id: number;
      is_active?: boolean | null;
      name: string;
      updated_at?: any | null;
    };
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type DeleteManyEmbeddingReviewVariables = Exact<{
  where: EmbeddingReviewsBoolExp;
}>;

export type DeleteManyEmbeddingReviewResponse = {
  __typename?: "mutation_root";
  delete_embedding_reviews?: {
    __typename?: "embedding_reviews_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "embedding_reviews";
      agent_review?: boolean | null;
      created_at: any;
      human_review?: boolean | null;
      id: any;
      notes?: string | null;
      updated_at?: any | null;
      research_embeddings: Array<{
        __typename?: "research_embeddings";
        chunk: string;
        created_at?: any | null;
        embedding?: any | null;
        embedding_review_id?: any | null;
        id: number;
        is_flagged?: boolean | null;
        research_id: any;
        updated_at: any;
        url?: string | null;
      }>;
    }>;
  } | null;
};

export type DeleteOneEmbeddingReviewVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneEmbeddingReviewResponse = {
  __typename?: "mutation_root";
  delete_embedding_reviews_by_pk?: {
    __typename?: "embedding_reviews";
    agent_review?: boolean | null;
    created_at: any;
    human_review?: boolean | null;
    id: any;
    notes?: string | null;
    updated_at?: any | null;
    research_embeddings: Array<{
      __typename?: "research_embeddings";
      chunk: string;
      created_at?: any | null;
      embedding?: any | null;
      embedding_review_id?: any | null;
      id: number;
      is_flagged?: boolean | null;
      research_id: any;
      updated_at: any;
      url?: string | null;
    }>;
  } | null;
};

export type DeleteManyErrorLogVariables = Exact<{
  where: ErrorLogsBoolExp;
}>;

export type DeleteManyErrorLogResponse = {
  __typename?: "mutation_root";
  delete_error_logs?: {
    __typename?: "error_logs_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "error_logs";
      context?: any | null;
      correlation_id?: any | null;
      created_at?: any | null;
      domain?: string | null;
      environment: string;
      error_hash?: string | null;
      error_pattern?: string | null;
      error_type: any;
      frequency_data?: any | null;
      github_repo?: string | null;
      id: any;
      is_new_pattern?: boolean | null;
      message: string;
      metadata?: any | null;
      related_errors?: any | null;
      request_id?: any | null;
      service_name: string;
      severity: any;
      stack_trace?: string | null;
      user_id?: any | null;
    }>;
  } | null;
};

export type DeleteOneErrorLogVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneErrorLogResponse = {
  __typename?: "mutation_root";
  delete_error_logs_by_pk?: {
    __typename?: "error_logs";
    context?: any | null;
    correlation_id?: any | null;
    created_at?: any | null;
    domain?: string | null;
    environment: string;
    error_hash?: string | null;
    error_pattern?: string | null;
    error_type: any;
    frequency_data?: any | null;
    github_repo?: string | null;
    id: any;
    is_new_pattern?: boolean | null;
    message: string;
    metadata?: any | null;
    related_errors?: any | null;
    request_id?: any | null;
    service_name: string;
    severity: any;
    stack_trace?: string | null;
    user_id?: any | null;
  } | null;
};

export type DeleteManyFeatureRequestVariables = Exact<{
  where: FeatureRequestsBoolExp;
}>;

export type DeleteManyFeatureRequestResponse = {
  __typename?: "mutation_root";
  delete_feature_requests?: {
    __typename?: "feature_requests_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feature_requests";
      created_at?: any | null;
      description?: string | null;
      downvotes?: number | null;
      engagement_score?: number | null;
      id: any;
      priority_score?: number | null;
      status: string;
      title: string;
      updated_at?: any | null;
      upvotes?: number | null;
      feature_votes: Array<{
        __typename?: "feature_votes";
        created_at?: any | null;
        feature_id: any;
        feedback?: string | null;
        id: any;
        updated_at?: any | null;
        user_id: any;
        vote_type: any;
      }>;
    }>;
  } | null;
};

export type DeleteOneFeatureRequestVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneFeatureRequestResponse = {
  __typename?: "mutation_root";
  delete_feature_requests_by_pk?: {
    __typename?: "feature_requests";
    created_at?: any | null;
    description?: string | null;
    downvotes?: number | null;
    engagement_score?: number | null;
    id: any;
    priority_score?: number | null;
    status: string;
    title: string;
    updated_at?: any | null;
    upvotes?: number | null;
    feature_votes: Array<{
      __typename?: "feature_votes";
      created_at?: any | null;
      feature_id: any;
      feedback?: string | null;
      id: any;
      updated_at?: any | null;
      user_id: any;
      vote_type: any;
    }>;
  } | null;
};

export type DeleteManyFeatureVoteVariables = Exact<{
  where: FeatureVotesBoolExp;
}>;

export type DeleteManyFeatureVoteResponse = {
  __typename?: "mutation_root";
  delete_feature_votes?: {
    __typename?: "feature_votes_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feature_votes";
      created_at?: any | null;
      feature_id: any;
      feedback?: string | null;
      id: any;
      updated_at?: any | null;
      user_id: any;
      vote_type: any;
      feature_request: {
        __typename?: "feature_requests";
        created_at?: any | null;
        description?: string | null;
        downvotes?: number | null;
        engagement_score?: number | null;
        id: any;
        priority_score?: number | null;
        status: string;
        title: string;
        updated_at?: any | null;
        upvotes?: number | null;
      };
    }>;
  } | null;
};

export type DeleteOneFeatureVoteVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneFeatureVoteResponse = {
  __typename?: "mutation_root";
  delete_feature_votes_by_pk?: {
    __typename?: "feature_votes";
    created_at?: any | null;
    feature_id: any;
    feedback?: string | null;
    id: any;
    updated_at?: any | null;
    user_id: any;
    vote_type: any;
    feature_request: {
      __typename?: "feature_requests";
      created_at?: any | null;
      description?: string | null;
      downvotes?: number | null;
      engagement_score?: number | null;
      id: any;
      priority_score?: number | null;
      status: string;
      title: string;
      updated_at?: any | null;
      upvotes?: number | null;
    };
  } | null;
};

export type DeleteManyFeedCategoryVariables = Exact<{
  where: FeedCategoriesBoolExp;
}>;

export type DeleteManyFeedCategoryResponse = {
  __typename?: "mutation_root";
  delete_feed_categories?: {
    __typename?: "feed_categories_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feed_categories";
      category_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
      category?: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      } | null;
      feed?: {
        __typename?: "feeds";
        created_at: any;
        id: any;
        name?: string | null;
        user_id?: any | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneFeedCategoryVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneFeedCategoryResponse = {
  __typename?: "mutation_root";
  delete_feed_categories_by_pk?: {
    __typename?: "feed_categories";
    category_id?: any | null;
    created_at: any;
    feed_id?: any | null;
    id: any;
    category?: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    } | null;
    feed?: {
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    } | null;
  } | null;
};

export type DeleteManyFeedSourceVariables = Exact<{
  where: FeedSourcesBoolExp;
}>;

export type DeleteManyFeedSourceResponse = {
  __typename?: "mutation_root";
  delete_feed_sources?: {
    __typename?: "feed_sources_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feed_sources";
      content_source_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
      content_source?: {
        __typename?: "content_sources";
        company_id?: any | null;
        content_type: any;
        created_at?: any | null;
        expected_count?: any | null;
        failed_count?: any | null;
        has_failed?: boolean | null;
        hash?: any | null;
        id: any;
        priority: any;
        refreshed_at?: any | null;
        rss_urls?: Array<string> | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        updated_at?: any | null;
        url: string;
      } | null;
      feed?: {
        __typename?: "feeds";
        created_at: any;
        id: any;
        name?: string | null;
        user_id?: any | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneFeedSourceVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneFeedSourceResponse = {
  __typename?: "mutation_root";
  delete_feed_sources_by_pk?: {
    __typename?: "feed_sources";
    content_source_id?: any | null;
    created_at: any;
    feed_id?: any | null;
    id: any;
    content_source?: {
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    } | null;
    feed?: {
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    } | null;
  } | null;
};

export type DeleteManyFeedbackVariables = Exact<{
  where: FeedbacksBoolExp;
}>;

export type DeleteManyFeedbackResponse = {
  __typename?: "mutation_root";
  delete_feedbacks?: {
    __typename?: "feedbacks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feedbacks";
      created_at: any;
      device_info?: string | null;
      feedback_status?: any | null;
      feedback_type?: any | null;
      id: number;
      message: string;
      page_identifier: string;
      rating?: number | null;
      resolution_comment?: string | null;
      updated_at: any;
      user_id?: any | null;
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneFeedbackVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneFeedbackResponse = {
  __typename?: "mutation_root";
  delete_feedbacks_by_pk?: {
    __typename?: "feedbacks";
    created_at: any;
    device_info?: string | null;
    feedback_status?: any | null;
    feedback_type?: any | null;
    id: number;
    message: string;
    page_identifier: string;
    rating?: number | null;
    resolution_comment?: string | null;
    updated_at: any;
    user_id?: any | null;
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type DeleteManyFeedVariables = Exact<{
  where: FeedsBoolExp;
}>;

export type DeleteManyFeedResponse = {
  __typename?: "mutation_root";
  delete_feeds?: {
    __typename?: "feeds_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
      feed_categories: Array<{
        __typename?: "feed_categories";
        category_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      feed_sources: Array<{
        __typename?: "feed_sources";
        content_source_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneFeedVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneFeedResponse = {
  __typename?: "mutation_root";
  delete_feeds_by_pk?: {
    __typename?: "feeds";
    created_at: any;
    id: any;
    name?: string | null;
    user_id?: any | null;
    feed_categories: Array<{
      __typename?: "feed_categories";
      category_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    feed_sources: Array<{
      __typename?: "feed_sources";
      content_source_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type DeleteManyFollowVariables = Exact<{
  where: FollowsBoolExp;
}>;

export type DeleteManyFollowResponse = {
  __typename?: "mutation_root";
  delete_follows?: {
    __typename?: "follows_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "follows";
      created_at?: any | null;
      followed_entity: any;
      followed_id: any;
      id: any;
      user_id: any;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneFollowVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneFollowResponse = {
  __typename?: "mutation_root";
  delete_follows_by_pk?: {
    __typename?: "follows";
    created_at?: any | null;
    followed_entity: any;
    followed_id: any;
    id: any;
    user_id: any;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type DeleteManyMetricDefinitionVariables = Exact<{
  where: MetricDefinitionsBoolExp;
}>;

export type DeleteManyMetricDefinitionResponse = {
  __typename?: "mutation_root";
  delete_metric_definitions?: {
    __typename?: "metric_definitions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "metric_definitions";
      category?: string | null;
      description?: string | null;
      id: number;
      is_dimensional?: boolean | null;
      name: string;
      type: string;
      unit?: string | null;
      company_metrics: Array<{
        __typename?: "company_metrics";
        company_id: any;
        crawl_id: any;
        id: any;
        metric_id?: number | null;
        timestamp: any;
        value: any;
      }>;
      spider_metrics: Array<{
        __typename?: "spider_metrics";
        crawl_id: any;
        id: any;
        metric_id?: number | null;
        timestamp: any;
        value: any;
      }>;
    }>;
  } | null;
};

export type DeleteOneMetricDefinitionVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneMetricDefinitionResponse = {
  __typename?: "mutation_root";
  delete_metric_definitions_by_pk?: {
    __typename?: "metric_definitions";
    category?: string | null;
    description?: string | null;
    id: number;
    is_dimensional?: boolean | null;
    name: string;
    type: string;
    unit?: string | null;
    company_metrics: Array<{
      __typename?: "company_metrics";
      company_id: any;
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
    }>;
    spider_metrics: Array<{
      __typename?: "spider_metrics";
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
    }>;
  } | null;
};

export type DeleteManyNewsVariables = Exact<{
  where: NewsBoolExp;
}>;

export type DeleteManyNewsResponse = {
  __typename?: "mutation_root";
  delete_news?: {
    __typename?: "news_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
      category?: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      } | null;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      content_source?: {
        __typename?: "content_sources";
        company_id?: any | null;
        content_type: any;
        created_at?: any | null;
        expected_count?: any | null;
        failed_count?: any | null;
        has_failed?: boolean | null;
        hash?: any | null;
        id: any;
        priority: any;
        refreshed_at?: any | null;
        rss_urls?: Array<string> | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        updated_at?: any | null;
        url: string;
      } | null;
      news_summaries: Array<{
        __typename?: "news_summaries";
        complexity_level?: any | null;
        created_at?: any | null;
        embedding?: any | null;
        id: any;
        is_current?: boolean | null;
        news_id: any;
        summary?: string | null;
        updated_at?: any | null;
        version: number;
      }>;
    }>;
  } | null;
};

export type DeleteOneNewsVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneNewsResponse = {
  __typename?: "mutation_root";
  delete_news_by_pk?: {
    __typename?: "news";
    author?: string | null;
    body?: string | null;
    category_id?: any | null;
    company_id?: any | null;
    content_source_id?: any | null;
    content_status: any;
    created_at: any;
    description?: string | null;
    failed_count?: any | null;
    featured_image?: string | null;
    has_summary: boolean;
    hash?: any | null;
    id: any;
    keywords?: any | null;
    published_at?: any | null;
    scrape_frequency: any;
    scraped_at?: any | null;
    title?: string | null;
    updated_at: any;
    url: string;
    category?: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    } | null;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    content_source?: {
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    } | null;
    news_summaries: Array<{
      __typename?: "news_summaries";
      complexity_level?: any | null;
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      is_current?: boolean | null;
      news_id: any;
      summary?: string | null;
      updated_at?: any | null;
      version: number;
    }>;
  } | null;
};

export type DeleteManyNewsSummaryVariables = Exact<{
  where: NewsSummariesBoolExp;
}>;

export type DeleteManyNewsSummaryResponse = {
  __typename?: "mutation_root";
  delete_news_summaries?: {
    __typename?: "news_summaries_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "news_summaries";
      complexity_level?: any | null;
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      is_current?: boolean | null;
      news_id: any;
      summary?: string | null;
      updated_at?: any | null;
      version: number;
      news: {
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      };
    }>;
  } | null;
};

export type DeleteOneNewsSummaryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneNewsSummaryResponse = {
  __typename?: "mutation_root";
  delete_news_summaries_by_pk?: {
    __typename?: "news_summaries";
    complexity_level?: any | null;
    created_at?: any | null;
    embedding?: any | null;
    id: any;
    is_current?: boolean | null;
    news_id: any;
    summary?: string | null;
    updated_at?: any | null;
    version: number;
    news: {
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    };
  } | null;
};

export type DeleteManyNewsTagVariables = Exact<{
  where: NewsTagsBoolExp;
}>;

export type DeleteManyNewsTagResponse = {
  __typename?: "mutation_root";
  delete_news_tags?: {
    __typename?: "news_tags_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "news_tags";
      id: number;
      news_id?: any | null;
      tag_id: number;
      tag: {
        __typename?: "tags";
        body?: string | null;
        created_at?: any | null;
        document_id?: string | null;
        id: number;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      };
    }>;
  } | null;
};

export type DeleteOneNewsTagVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneNewsTagResponse = {
  __typename?: "mutation_root";
  delete_news_tags_by_pk?: {
    __typename?: "news_tags";
    id: number;
    news_id?: any | null;
    tag_id: number;
    tag: {
      __typename?: "tags";
      body?: string | null;
      created_at?: any | null;
      document_id?: string | null;
      id: number;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    };
  } | null;
};

export type DeleteManyNewsletterVariables = Exact<{
  where: NewslettersBoolExp;
}>;

export type DeleteManyNewsletterResponse = {
  __typename?: "mutation_root";
  delete_newsletters?: {
    __typename?: "newsletters_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "newsletters";
      content_status: any;
      created_at?: any | null;
      end_date: any;
      frequency: string;
      generated_content?: string | null;
      id: any;
      start_date: any;
      title: string;
      updated_at?: any | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null;
};

export type DeleteOneNewsletterVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneNewsletterResponse = {
  __typename?: "mutation_root";
  delete_newsletters_by_pk?: {
    __typename?: "newsletters";
    content_status: any;
    created_at?: any | null;
    end_date: any;
    frequency: string;
    generated_content?: string | null;
    id: any;
    start_date: any;
    title: string;
    updated_at?: any | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type DeleteManyPaymentProviderVariables = Exact<{
  where: PaymentProvidersBoolExp;
}>;

export type DeleteManyPaymentProviderResponse = {
  __typename?: "mutation_root";
  delete_payment_providers?: {
    __typename?: "payment_providers_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "payment_providers";
      created_at?: any | null;
      id: number;
      is_active?: boolean | null;
      name: string;
      updated_at?: any | null;
      customer_payments: Array<{
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      }>;
      customer_subscriptions: Array<{
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      }>;
    }>;
  } | null;
};

export type DeleteOnePaymentProviderVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOnePaymentProviderResponse = {
  __typename?: "mutation_root";
  delete_payment_providers_by_pk?: {
    __typename?: "payment_providers";
    created_at?: any | null;
    id: number;
    is_active?: boolean | null;
    name: string;
    updated_at?: any | null;
    customer_payments: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
    customer_subscriptions: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  } | null;
};

export type DeleteManyPlanPermissionVariables = Exact<{
  where: PlanPermissionsBoolExp;
}>;

export type DeleteManyPlanPermissionResponse = {
  __typename?: "mutation_root";
  delete_plan_permissions?: {
    __typename?: "plan_permissions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "plan_permissions";
      feature: string;
      id: number;
      plan: any;
    }>;
  } | null;
};

export type DeleteOnePlanPermissionVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOnePlanPermissionResponse = {
  __typename?: "mutation_root";
  delete_plan_permissions_by_pk?: {
    __typename?: "plan_permissions";
    feature: string;
    id: number;
    plan: any;
  } | null;
};

export type DeleteManyRecentErrorVariables = Exact<{
  where: RecentErrorsBoolExp;
}>;

export type DeleteManyRecentErrorResponse = {
  __typename?: "mutation_root";
  delete_recent_errors?: {
    __typename?: "recent_errors_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "recent_errors";
      created_at?: any | null;
      error_type?: any | null;
      message?: string | null;
      metadata?: any | null;
      service_name?: string | null;
      severity?: any | null;
    }>;
  } | null;
};

export type DeleteManyReferralVariables = Exact<{
  where: ReferralsBoolExp;
}>;

export type DeleteManyReferralResponse = {
  __typename?: "mutation_root";
  delete_referrals?: {
    __typename?: "referrals_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "referrals";
      browser?: string | null;
      client_fingerprint?: string | null;
      conversion_value?: any | null;
      converted_at?: any | null;
      country_code?: string | null;
      created_at?: any | null;
      device_type?: string | null;
      id: any;
      ip_address?: any | null;
      is_suspicious?: boolean | null;
      landing_page?: string | null;
      last_failed_attempt?: any | null;
      referral_status?: any | null;
      referrer_code: string;
      region?: string | null;
      security_flags?: any | null;
      user_agent?: string | null;
      utm_campaign?: string | null;
      utm_medium?: string | null;
      utm_source?: string | null;
      validation_attempts?: number | null;
      visitor_id: any;
    }>;
  } | null;
};

export type DeleteOneReferralVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneReferralResponse = {
  __typename?: "mutation_root";
  delete_referrals_by_pk?: {
    __typename?: "referrals";
    browser?: string | null;
    client_fingerprint?: string | null;
    conversion_value?: any | null;
    converted_at?: any | null;
    country_code?: string | null;
    created_at?: any | null;
    device_type?: string | null;
    id: any;
    ip_address?: any | null;
    is_suspicious?: boolean | null;
    landing_page?: string | null;
    last_failed_attempt?: any | null;
    referral_status?: any | null;
    referrer_code: string;
    region?: string | null;
    security_flags?: any | null;
    user_agent?: string | null;
    utm_campaign?: string | null;
    utm_medium?: string | null;
    utm_source?: string | null;
    validation_attempts?: number | null;
    visitor_id: any;
  } | null;
};

export type DeleteManyReferrerBlockVariables = Exact<{
  where: ReferrerBlocksBoolExp;
}>;

export type DeleteManyReferrerBlockResponse = {
  __typename?: "mutation_root";
  delete_referrer_blocks?: {
    __typename?: "referrer_blocks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "referrer_blocks";
      blocked_at?: any | null;
      blocked_by: string;
      created_at?: any | null;
      id: any;
      is_permanent?: boolean | null;
      reason?: string | null;
      referrer_code: string;
      updated_at?: any | null;
    }>;
  } | null;
};

export type DeleteOneReferrerBlockVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneReferrerBlockResponse = {
  __typename?: "mutation_root";
  delete_referrer_blocks_by_pk?: {
    __typename?: "referrer_blocks";
    blocked_at?: any | null;
    blocked_by: string;
    created_at?: any | null;
    id: any;
    is_permanent?: boolean | null;
    reason?: string | null;
    referrer_code: string;
    updated_at?: any | null;
  } | null;
};

export type DeleteManyResearchVariables = Exact<{
  where: ResearchBoolExp;
}>;

export type DeleteManyResearchResponse = {
  __typename?: "mutation_root";
  delete_research?: {
    __typename?: "research_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      research_embedding?: {
        __typename?: "research_embeddings";
        chunk: string;
        created_at?: any | null;
        embedding?: any | null;
        embedding_review_id?: any | null;
        id: number;
        is_flagged?: boolean | null;
        research_id: any;
        updated_at: any;
        url?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneResearchVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneResearchResponse = {
  __typename?: "mutation_root";
  delete_research_by_pk?: {
    __typename?: "research";
    abstract?: string | null;
    abstract_url: string;
    affiliations?: any | null;
    authors?: any | null;
    category?: string | null;
    comments?: string | null;
    content_status: any;
    created_at: any;
    doi_url?: string | null;
    figure_count?: any | null;
    has_embedding?: boolean | null;
    id: any;
    is_flagged: boolean;
    keywords?: string | null;
    month?: string | null;
    page_count?: any | null;
    pdf_url?: string | null;
    published_at?: any | null;
    published_in?: string | null;
    summary?: string | null;
    table_count?: any | null;
    title?: string | null;
    updated_at?: any | null;
    version?: any | null;
    year?: string | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    research_embedding?: {
      __typename?: "research_embeddings";
      chunk: string;
      created_at?: any | null;
      embedding?: any | null;
      embedding_review_id?: any | null;
      id: number;
      is_flagged?: boolean | null;
      research_id: any;
      updated_at: any;
      url?: string | null;
    } | null;
  } | null;
};

export type DeleteManyResearchEmbeddingVariables = Exact<{
  where: ResearchEmbeddingsBoolExp;
}>;

export type DeleteManyResearchEmbeddingResponse = {
  __typename?: "mutation_root";
  delete_research_embeddings?: {
    __typename?: "research_embeddings_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "research_embeddings";
      chunk: string;
      created_at?: any | null;
      embedding?: any | null;
      embedding_review_id?: any | null;
      id: number;
      is_flagged?: boolean | null;
      research_id: any;
      updated_at: any;
      url?: string | null;
      embedding_review?: {
        __typename?: "embedding_reviews";
        agent_review?: boolean | null;
        created_at: any;
        human_review?: boolean | null;
        id: any;
        notes?: string | null;
        updated_at?: any | null;
      } | null;
      research: {
        __typename?: "research";
        abstract?: string | null;
        abstract_url: string;
        affiliations?: any | null;
        authors?: any | null;
        category?: string | null;
        comments?: string | null;
        content_status: any;
        created_at: any;
        doi_url?: string | null;
        figure_count?: any | null;
        has_embedding?: boolean | null;
        id: any;
        is_flagged: boolean;
        keywords?: string | null;
        month?: string | null;
        page_count?: any | null;
        pdf_url?: string | null;
        published_at?: any | null;
        published_in?: string | null;
        summary?: string | null;
        table_count?: any | null;
        title?: string | null;
        updated_at?: any | null;
        version?: any | null;
        year?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneResearchEmbeddingVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneResearchEmbeddingResponse = {
  __typename?: "mutation_root";
  delete_research_embeddings_by_pk?: {
    __typename?: "research_embeddings";
    chunk: string;
    created_at?: any | null;
    embedding?: any | null;
    embedding_review_id?: any | null;
    id: number;
    is_flagged?: boolean | null;
    research_id: any;
    updated_at: any;
    url?: string | null;
    embedding_review?: {
      __typename?: "embedding_reviews";
      agent_review?: boolean | null;
      created_at: any;
      human_review?: boolean | null;
      id: any;
      notes?: string | null;
      updated_at?: any | null;
    } | null;
    research: {
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
    };
  } | null;
};

export type DeleteManyResponseVariables = Exact<{
  where: ResponsesBoolExp;
}>;

export type DeleteManyResponseResponse = {
  __typename?: "mutation_root";
  delete_responses?: {
    __typename?: "responses_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "responses";
      created_at?: any | null;
      downvotes?: number | null;
      id: any;
      output: string;
      search_id: any;
      upvotes?: number | null;
      search: {
        __typename?: "searches";
        created_at?: any | null;
        embedding?: any | null;
        id: any;
        input: string;
        tokens_used?: any | null;
        user_ids?: Array<any> | null;
      };
    }>;
  } | null;
};

export type DeleteOneResponseVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneResponseResponse = {
  __typename?: "mutation_root";
  delete_responses_by_pk?: {
    __typename?: "responses";
    created_at?: any | null;
    downvotes?: number | null;
    id: any;
    output: string;
    search_id: any;
    upvotes?: number | null;
    search: {
      __typename?: "searches";
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      input: string;
      tokens_used?: any | null;
      user_ids?: Array<any> | null;
    };
  } | null;
};

export type DeleteManyRoleHierarchyVariables = Exact<{
  where: RoleHierarchyBoolExp;
}>;

export type DeleteManyRoleHierarchyResponse = {
  __typename?: "mutation_root";
  delete_role_hierarchy?: {
    __typename?: "role_hierarchy_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "role_hierarchy";
      child_role: any;
      parent_role: any;
    }>;
  } | null;
};

export type DeleteOneRoleHierarchyVariables = Exact<{
  child_role: Scalars["app_role_enum"]["input"];
  parent_role: Scalars["app_role_enum"]["input"];
}>;

export type DeleteOneRoleHierarchyResponse = {
  __typename?: "mutation_root";
  delete_role_hierarchy_by_pk?: {
    __typename?: "role_hierarchy";
    child_role: any;
    parent_role: any;
  } | null;
};

export type DeleteManyRolePermissionVariables = Exact<{
  where: RolePermissionsBoolExp;
}>;

export type DeleteManyRolePermissionResponse = {
  __typename?: "mutation_root";
  delete_role_permissions?: {
    __typename?: "role_permissions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "role_permissions";
      cached_permissions?: any | null;
      conditions?: any | null;
      id: number;
      inherit_from?: Array<any> | null;
      last_updated?: any | null;
      permissions?: any | null;
      role: any;
      table_name: string;
    }>;
  } | null;
};

export type DeleteOneRolePermissionVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneRolePermissionResponse = {
  __typename?: "mutation_root";
  delete_role_permissions_by_pk?: {
    __typename?: "role_permissions";
    cached_permissions?: any | null;
    conditions?: any | null;
    id: number;
    inherit_from?: Array<any> | null;
    last_updated?: any | null;
    permissions?: any | null;
    role: any;
    table_name: string;
  } | null;
};

export type DeleteManyRolePermissionsMaterializedVariables = Exact<{
  where: RolePermissionsMaterializedBoolExp;
}>;

export type DeleteManyRolePermissionsMaterializedResponse = {
  __typename?: "mutation_root";
  delete_role_permissions_materialized?: {
    __typename?: "role_permissions_materialized_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "role_permissions_materialized";
      last_updated?: any | null;
      permissions: any;
      role: any;
    }>;
  } | null;
};

export type DeleteOneRolePermissionsMaterializedVariables = Exact<{
  role: Scalars["app_role_enum"]["input"];
}>;

export type DeleteOneRolePermissionsMaterializedResponse = {
  __typename?: "mutation_root";
  delete_role_permissions_materialized_by_pk?: {
    __typename?: "role_permissions_materialized";
    last_updated?: any | null;
    permissions: any;
    role: any;
  } | null;
};

export type DeleteManyScoringWeightVariables = Exact<{
  where: ScoringWeightsBoolExp;
}>;

export type DeleteManyScoringWeightResponse = {
  __typename?: "mutation_root";
  delete_scoring_weights?: {
    __typename?: "scoring_weights_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "scoring_weights";
      description?: string | null;
      id: any;
      name: string;
      updated_at?: any | null;
      weight: any;
    }>;
  } | null;
};

export type DeleteOneScoringWeightVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneScoringWeightResponse = {
  __typename?: "mutation_root";
  delete_scoring_weights_by_pk?: {
    __typename?: "scoring_weights";
    description?: string | null;
    id: any;
    name: string;
    updated_at?: any | null;
    weight: any;
  } | null;
};

export type DeleteManySearchVariables = Exact<{
  where: SearchesBoolExp;
}>;

export type DeleteManySearchResponse = {
  __typename?: "mutation_root";
  delete_searches?: {
    __typename?: "searches_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "searches";
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      input: string;
      tokens_used?: any | null;
      user_ids?: Array<any> | null;
      responses: Array<{
        __typename?: "responses";
        created_at?: any | null;
        downvotes?: number | null;
        id: any;
        output: string;
        search_id: any;
        upvotes?: number | null;
      }>;
    }>;
  } | null;
};

export type DeleteOneSearchVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneSearchResponse = {
  __typename?: "mutation_root";
  delete_searches_by_pk?: {
    __typename?: "searches";
    created_at?: any | null;
    embedding?: any | null;
    id: any;
    input: string;
    tokens_used?: any | null;
    user_ids?: Array<any> | null;
    responses: Array<{
      __typename?: "responses";
      created_at?: any | null;
      downvotes?: number | null;
      id: any;
      output: string;
      search_id: any;
      upvotes?: number | null;
    }>;
  } | null;
};

export type DeleteManySocialMediaVariables = Exact<{
  where: SocialMediaBoolExp;
}>;

export type DeleteManySocialMediaResponse = {
  __typename?: "mutation_root";
  delete_social_media?: {
    __typename?: "social_media_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "social_media";
      created_at?: any | null;
      facebook_url?: string | null;
      id: number;
      instagram_url?: string | null;
      linkedin_url?: string | null;
      twitter_url?: string | null;
      updated_at?: any | null;
      youtube_url?: string | null;
      companies: Array<{
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      }>;
    }>;
  } | null;
};

export type DeleteOneSocialMediaVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneSocialMediaResponse = {
  __typename?: "mutation_root";
  delete_social_media_by_pk?: {
    __typename?: "social_media";
    created_at?: any | null;
    facebook_url?: string | null;
    id: number;
    instagram_url?: string | null;
    linkedin_url?: string | null;
    twitter_url?: string | null;
    updated_at?: any | null;
    youtube_url?: string | null;
    companies: Array<{
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    }>;
  } | null;
};

export type DeleteManySpiderMetricVariables = Exact<{
  where: SpiderMetricsBoolExp;
}>;

export type DeleteManySpiderMetricResponse = {
  __typename?: "mutation_root";
  delete_spider_metrics?: {
    __typename?: "spider_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "spider_metrics";
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
      metric_definition?: {
        __typename?: "metric_definitions";
        category?: string | null;
        description?: string | null;
        id: number;
        is_dimensional?: boolean | null;
        name: string;
        type: string;
        unit?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneSpiderMetricVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneSpiderMetricResponse = {
  __typename?: "mutation_root";
  delete_spider_metrics_by_pk?: {
    __typename?: "spider_metrics";
    crawl_id: any;
    id: any;
    metric_id?: number | null;
    timestamp: any;
    value: any;
    metric_definition?: {
      __typename?: "metric_definitions";
      category?: string | null;
      description?: string | null;
      id: number;
      is_dimensional?: boolean | null;
      name: string;
      type: string;
      unit?: string | null;
    } | null;
  } | null;
};

export type DeleteManyStrapiMigrationVariables = Exact<{
  where: StrapiMigrationsBoolExp;
}>;

export type DeleteManyStrapiMigrationResponse = {
  __typename?: "mutation_root";
  delete_strapi_migrations?: {
    __typename?: "strapi_migrations_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "strapi_migrations";
      id: number;
      name?: string | null;
      time?: any | null;
    }>;
  } | null;
};

export type DeleteOneStrapiMigrationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneStrapiMigrationResponse = {
  __typename?: "mutation_root";
  delete_strapi_migrations_by_pk?: {
    __typename?: "strapi_migrations";
    id: number;
    name?: string | null;
    time?: any | null;
  } | null;
};

export type DeleteManyStrapiMigrationsInternalVariables = Exact<{
  where: StrapiMigrationsInternalBoolExp;
}>;

export type DeleteManyStrapiMigrationsInternalResponse = {
  __typename?: "mutation_root";
  delete_strapi_migrations_internal?: {
    __typename?: "strapi_migrations_internal_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "strapi_migrations_internal";
      id: number;
      name?: string | null;
      time?: any | null;
    }>;
  } | null;
};

export type DeleteOneStrapiMigrationsInternalVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneStrapiMigrationsInternalResponse = {
  __typename?: "mutation_root";
  delete_strapi_migrations_internal_by_pk?: {
    __typename?: "strapi_migrations_internal";
    id: number;
    name?: string | null;
    time?: any | null;
  } | null;
};

export type DeleteManyTableMaintenanceLogVariables = Exact<{
  where: TableMaintenanceLogBoolExp;
}>;

export type DeleteManyTableMaintenanceLogResponse = {
  __typename?: "mutation_root";
  delete_table_maintenance_log?: {
    __typename?: "table_maintenance_log_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_maintenance_log";
      detail?: string | null;
      id: number;
      logged_at?: any | null;
      operation?: string | null;
    }>;
  } | null;
};

export type DeleteOneTableMaintenanceLogVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneTableMaintenanceLogResponse = {
  __typename?: "mutation_root";
  delete_table_maintenance_log_by_pk?: {
    __typename?: "table_maintenance_log";
    detail?: string | null;
    id: number;
    logged_at?: any | null;
    operation?: string | null;
  } | null;
};

export type DeleteManyTableQueryPerformanceVariables = Exact<{
  where: TableQueryPerformanceBoolExp;
}>;

export type DeleteManyTableQueryPerformanceResponse = {
  __typename?: "mutation_root";
  delete_table_query_performance?: {
    __typename?: "table_query_performance_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_query_performance";
      avg_duration?: any | null;
      capture_time?: any | null;
      execution_count?: any | null;
      query?: string | null;
    }>;
  } | null;
};

export type DeleteManyTableSequenceUsageVariables = Exact<{
  where: TableSequenceUsageBoolExp;
}>;

export type DeleteManyTableSequenceUsageResponse = {
  __typename?: "mutation_root";
  delete_table_sequence_usage?: {
    __typename?: "table_sequence_usage_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_sequence_usage";
      capture_time?: any | null;
      current_value?: any | null;
      max_value?: any | null;
      sequence_name?: string | null;
    }>;
  } | null;
};

export type DeleteManyTableStatisticVariables = Exact<{
  where: TableStatisticsBoolExp;
}>;

export type DeleteManyTableStatisticResponse = {
  __typename?: "mutation_root";
  delete_table_statistics?: {
    __typename?: "table_statistics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_statistics";
      buffer_cache_hit_ratio?: any | null;
      capture_time: any;
      dead_tuples?: any | null;
      estimated_bloat_ratio?: any | null;
      index_scan_count?: any | null;
      index_size?: any | null;
      index_usage?: any | null;
      last_analyze?: any | null;
      last_vacuum?: any | null;
      live_tuples?: any | null;
      row_count?: any | null;
      seq_scan_count?: any | null;
      table_name: string;
      table_size?: any | null;
    }>;
  } | null;
};

export type DeleteOneTableStatisticVariables = Exact<{
  capture_time: Scalars["timestamptz"]["input"];
  table_name: Scalars["String"]["input"];
}>;

export type DeleteOneTableStatisticResponse = {
  __typename?: "mutation_root";
  delete_table_statistics_by_pk?: {
    __typename?: "table_statistics";
    buffer_cache_hit_ratio?: any | null;
    capture_time: any;
    dead_tuples?: any | null;
    estimated_bloat_ratio?: any | null;
    index_scan_count?: any | null;
    index_size?: any | null;
    index_usage?: any | null;
    last_analyze?: any | null;
    last_vacuum?: any | null;
    live_tuples?: any | null;
    row_count?: any | null;
    seq_scan_count?: any | null;
    table_name: string;
    table_size?: any | null;
  } | null;
};

export type DeleteManyTagVariables = Exact<{
  where: TagsBoolExp;
}>;

export type DeleteManyTagResponse = {
  __typename?: "mutation_root";
  delete_tags?: {
    __typename?: "tags_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "tags";
      body?: string | null;
      created_at?: any | null;
      document_id?: string | null;
      id: number;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
      content_tags: Array<{
        __typename?: "content_tags";
        content_id: any;
        tag_id: number;
      }>;
      news_tags: Array<{
        __typename?: "news_tags";
        id: number;
        news_id?: any | null;
        tag_id: number;
      }>;
    }>;
  } | null;
};

export type DeleteOneTagVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneTagResponse = {
  __typename?: "mutation_root";
  delete_tags_by_pk?: {
    __typename?: "tags";
    body?: string | null;
    created_at?: any | null;
    document_id?: string | null;
    id: number;
    locale?: string | null;
    name: string;
    published_at?: string | null;
    updated_at?: any | null;
    content_tags: Array<{
      __typename?: "content_tags";
      content_id: any;
      tag_id: number;
    }>;
    news_tags: Array<{
      __typename?: "news_tags";
      id: number;
      news_id?: any | null;
      tag_id: number;
    }>;
  } | null;
};

export type DeleteManyUserMetricVariables = Exact<{
  where: UserMetricsBoolExp;
}>;

export type DeleteManyUserMetricResponse = {
  __typename?: "mutation_root";
  delete_user_metrics?: {
    __typename?: "user_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "user_metrics";
      achievements?: any | null;
      best_streak?: number | null;
      created_at?: any | null;
      current_level?: number | null;
      current_streak?: number | null;
      current_xp?: number | null;
      downvote_count?: number | null;
      id: any;
      interaction_stats?: any | null;
      last_vote_date?: any | null;
      multipliers?: any | null;
      points?: number | null;
      points_breakdown?: any | null;
      titles?: any | null;
      today_vote_count?: number | null;
      total_reading_time?: number | null;
      total_votes?: number | null;
      updated_at?: any | null;
      upvote_count?: number | null;
      user_id: any;
      vote_accuracy?: any | null;
      xp_to_next_level?: number | null;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneUserMetricVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneUserMetricResponse = {
  __typename?: "mutation_root";
  delete_user_metrics_by_pk?: {
    __typename?: "user_metrics";
    achievements?: any | null;
    best_streak?: number | null;
    created_at?: any | null;
    current_level?: number | null;
    current_streak?: number | null;
    current_xp?: number | null;
    downvote_count?: number | null;
    id: any;
    interaction_stats?: any | null;
    last_vote_date?: any | null;
    multipliers?: any | null;
    points?: number | null;
    points_breakdown?: any | null;
    titles?: any | null;
    today_vote_count?: number | null;
    total_reading_time?: number | null;
    total_votes?: number | null;
    updated_at?: any | null;
    upvote_count?: number | null;
    user_id: any;
    vote_accuracy?: any | null;
    xp_to_next_level?: number | null;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type DeleteManyUserProfileVariables = Exact<{
  where: UserProfilesBoolExp;
}>;

export type DeleteManyUserProfileResponse = {
  __typename?: "mutation_root";
  delete_user_profiles?: {
    __typename?: "user_profiles_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      comments: Array<{
        __typename?: "comments";
        content: string;
        content_id: any;
        content_type: any;
        created_at?: any | null;
        id: any;
        parent_comment_id?: any | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      company_employees: Array<{
        __typename?: "company_employees";
        access_level: any;
        company_id?: any | null;
        created_at?: any | null;
        end_date?: any | null;
        id: any;
        job_description?: string | null;
        role: string;
        start_date?: any | null;
        status?: boolean | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      contacts: Array<{
        __typename?: "contacts";
        company_id?: any | null;
        contact_type?: any | null;
        created_at?: any | null;
        email?: string | null;
        id: number;
        is_primary?: boolean | null;
        phone?: string | null;
        privacy_level?: any | null;
        title?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      content_source_visits: Array<{
        __typename?: "content_source_visits";
        content_id: any;
        created_at?: any | null;
        id: any;
        user_id?: any | null;
      }>;
      customer_payments: Array<{
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      }>;
      customer_subscriptions: Array<{
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      feedbacks: Array<{
        __typename?: "feedbacks";
        created_at: any;
        device_info?: string | null;
        feedback_status?: any | null;
        feedback_type?: any | null;
        id: number;
        message: string;
        page_identifier: string;
        rating?: number | null;
        resolution_comment?: string | null;
        updated_at: any;
        user_id?: any | null;
      }>;
      feeds: Array<{
        __typename?: "feeds";
        created_at: any;
        id: any;
        name?: string | null;
        user_id?: any | null;
      }>;
      follows: Array<{
        __typename?: "follows";
        created_at?: any | null;
        followed_entity: any;
        followed_id: any;
        id: any;
        user_id: any;
      }>;
      user_metric?: {
        __typename?: "user_metrics";
        achievements?: any | null;
        best_streak?: number | null;
        created_at?: any | null;
        current_level?: number | null;
        current_streak?: number | null;
        current_xp?: number | null;
        downvote_count?: number | null;
        id: any;
        interaction_stats?: any | null;
        last_vote_date?: any | null;
        multipliers?: any | null;
        points?: number | null;
        points_breakdown?: any | null;
        titles?: any | null;
        today_vote_count?: number | null;
        total_reading_time?: number | null;
        total_votes?: number | null;
        updated_at?: any | null;
        upvote_count?: number | null;
        user_id: any;
        vote_accuracy?: any | null;
        xp_to_next_level?: number | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneUserProfileVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneUserProfileResponse = {
  __typename?: "mutation_root";
  delete_user_profiles_by_pk?: {
    __typename?: "user_profiles";
    avatar?: string | null;
    created_at?: any | null;
    dob?: any | null;
    email: string;
    followed_count?: number | null;
    followers_count?: number | null;
    gender_id?: any | null;
    given_name?: string | null;
    id: any;
    introduction?: string | null;
    is_active?: boolean | null;
    last_seen?: any | null;
    plan?: any | null;
    role: any;
    surname?: string | null;
    updated_at?: any | null;
    username?: string | null;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    comments: Array<{
      __typename?: "comments";
      content: string;
      content_id: any;
      content_type: any;
      created_at?: any | null;
      id: any;
      parent_comment_id?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    company_employees: Array<{
      __typename?: "company_employees";
      access_level: any;
      company_id?: any | null;
      created_at?: any | null;
      end_date?: any | null;
      id: any;
      job_description?: string | null;
      role: string;
      start_date?: any | null;
      status?: boolean | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    contacts: Array<{
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    content_source_visits: Array<{
      __typename?: "content_source_visits";
      content_id: any;
      created_at?: any | null;
      id: any;
      user_id?: any | null;
    }>;
    customer_payments: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
    customer_subscriptions: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    feedbacks: Array<{
      __typename?: "feedbacks";
      created_at: any;
      device_info?: string | null;
      feedback_status?: any | null;
      feedback_type?: any | null;
      id: number;
      message: string;
      page_identifier: string;
      rating?: number | null;
      resolution_comment?: string | null;
      updated_at: any;
      user_id?: any | null;
    }>;
    feeds: Array<{
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    }>;
    follows: Array<{
      __typename?: "follows";
      created_at?: any | null;
      followed_entity: any;
      followed_id: any;
      id: any;
      user_id: any;
    }>;
    user_metric?: {
      __typename?: "user_metrics";
      achievements?: any | null;
      best_streak?: number | null;
      created_at?: any | null;
      current_level?: number | null;
      current_streak?: number | null;
      current_xp?: number | null;
      downvote_count?: number | null;
      id: any;
      interaction_stats?: any | null;
      last_vote_date?: any | null;
      multipliers?: any | null;
      points?: number | null;
      points_breakdown?: any | null;
      titles?: any | null;
      today_vote_count?: number | null;
      total_reading_time?: number | null;
      total_votes?: number | null;
      updated_at?: any | null;
      upvote_count?: number | null;
      user_id: any;
      vote_accuracy?: any | null;
      xp_to_next_level?: number | null;
    } | null;
  } | null;
};

export type DeleteManyVoteVariables = Exact<{
  where: VotesBoolExp;
}>;

export type DeleteManyVoteResponse = {
  __typename?: "mutation_root";
  delete_votes?: {
    __typename?: "votes_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "votes";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      id: any;
      user_id: any;
      vote_type: any;
    }>;
  } | null;
};

export type DeleteOneVoteVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneVoteResponse = {
  __typename?: "mutation_root";
  delete_votes_by_pk?: {
    __typename?: "votes";
    content_id: any;
    content_type: string;
    created_at?: any | null;
    id: any;
    user_id: any;
    vote_type: any;
  } | null;
};

export type DeleteManyWorkflowVariables = Exact<{
  where: WorkflowsBoolExp;
}>;

export type DeleteManyWorkflowResponse = {
  __typename?: "mutation_root";
  delete_workflows?: {
    __typename?: "workflows_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "workflows";
      completed_at?: any | null;
      created_at?: any | null;
      id: any;
      metadata?: any | null;
      name: string;
      started_at?: any | null;
      status: any;
      updated_at?: any | null;
    }>;
  } | null;
};

export type DeleteOneWorkflowVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneWorkflowResponse = {
  __typename?: "mutation_root";
  delete_workflows_by_pk?: {
    __typename?: "workflows";
    completed_at?: any | null;
    created_at?: any | null;
    id: any;
    metadata?: any | null;
    name: string;
    started_at?: any | null;
    status: any;
    updated_at?: any | null;
  } | null;
};

export type CreateManyAdDailyMetricVariables = Exact<{
  objects: Array<AdDailyMetricsInsertInput> | AdDailyMetricsInsertInput;
  on_conflict?: InputMaybe<AdDailyMetricsOnConflict>;
}>;

export type CreateManyAdDailyMetricResponse = {
  __typename?: "mutation_root";
  insert_ad_daily_metrics?: {
    __typename?: "ad_daily_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ad_daily_metrics";
      clicks?: number | null;
      created_at?: any | null;
      date: any;
      id: any;
      updated_at?: any | null;
      variant_id?: any | null;
      views?: number | null;
      ad_variant?: {
        __typename?: "ad_variants";
        active?: boolean | null;
        ad_id: any;
        content: any;
        created_at?: any | null;
        id: any;
        is_control?: boolean | null;
        performance_metrics?: any | null;
        updated_at?: any | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneAdDailyMetricVariables = Exact<{
  object: AdDailyMetricsInsertInput;
  on_conflict?: InputMaybe<AdDailyMetricsOnConflict>;
}>;

export type CreateOneAdDailyMetricResponse = {
  __typename?: "mutation_root";
  insert_ad_daily_metrics_one?: {
    __typename?: "ad_daily_metrics";
    clicks?: number | null;
    created_at?: any | null;
    date: any;
    id: any;
    updated_at?: any | null;
    variant_id?: any | null;
    views?: number | null;
    ad_variant?: {
      __typename?: "ad_variants";
      active?: boolean | null;
      ad_id: any;
      content: any;
      created_at?: any | null;
      id: any;
      is_control?: boolean | null;
      performance_metrics?: any | null;
      updated_at?: any | null;
    } | null;
  } | null;
};

export type CreateManyAdPackageVariables = Exact<{
  objects: Array<AdPackagesInsertInput> | AdPackagesInsertInput;
  on_conflict?: InputMaybe<AdPackagesOnConflict>;
}>;

export type CreateManyAdPackageResponse = {
  __typename?: "mutation_root";
  insert_ad_packages?: {
    __typename?: "ad_packages_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ad_packages";
      active?: boolean | null;
      avg_roi?: any | null;
      created_at?: any | null;
      description: string;
      expected_ctr?: any | null;
      features: Array<string>;
      id: any;
      name: string;
      position: string;
      price: any;
      updated_at?: any | null;
      view_frequency?: any | null;
      ads: Array<{
        __typename?: "ads";
        active?: boolean | null;
        company_id?: any | null;
        created_at?: any | null;
        end_date: any;
        id: any;
        package_id?: any | null;
        start_date: any;
        updated_at?: any | null;
      }>;
    }>;
  } | null;
};

export type CreateOneAdPackageVariables = Exact<{
  object: AdPackagesInsertInput;
  on_conflict?: InputMaybe<AdPackagesOnConflict>;
}>;

export type CreateOneAdPackageResponse = {
  __typename?: "mutation_root";
  insert_ad_packages_one?: {
    __typename?: "ad_packages";
    active?: boolean | null;
    avg_roi?: any | null;
    created_at?: any | null;
    description: string;
    expected_ctr?: any | null;
    features: Array<string>;
    id: any;
    name: string;
    position: string;
    price: any;
    updated_at?: any | null;
    view_frequency?: any | null;
    ads: Array<{
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    }>;
  } | null;
};

export type CreateManyAdVariantVariables = Exact<{
  objects: Array<AdVariantsInsertInput> | AdVariantsInsertInput;
  on_conflict?: InputMaybe<AdVariantsOnConflict>;
}>;

export type CreateManyAdVariantResponse = {
  __typename?: "mutation_root";
  insert_ad_variants?: {
    __typename?: "ad_variants_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ad_variants";
      active?: boolean | null;
      ad_id: any;
      content: any;
      created_at?: any | null;
      id: any;
      is_control?: boolean | null;
      performance_metrics?: any | null;
      updated_at?: any | null;
      ad: {
        __typename?: "ads";
        active?: boolean | null;
        company_id?: any | null;
        created_at?: any | null;
        end_date: any;
        id: any;
        package_id?: any | null;
        start_date: any;
        updated_at?: any | null;
      };
      ad_daily_metrics: Array<{
        __typename?: "ad_daily_metrics";
        clicks?: number | null;
        created_at?: any | null;
        date: any;
        id: any;
        updated_at?: any | null;
        variant_id?: any | null;
        views?: number | null;
      }>;
    }>;
  } | null;
};

export type CreateOneAdVariantVariables = Exact<{
  object: AdVariantsInsertInput;
  on_conflict?: InputMaybe<AdVariantsOnConflict>;
}>;

export type CreateOneAdVariantResponse = {
  __typename?: "mutation_root";
  insert_ad_variants_one?: {
    __typename?: "ad_variants";
    active?: boolean | null;
    ad_id: any;
    content: any;
    created_at?: any | null;
    id: any;
    is_control?: boolean | null;
    performance_metrics?: any | null;
    updated_at?: any | null;
    ad: {
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    };
    ad_daily_metrics: Array<{
      __typename?: "ad_daily_metrics";
      clicks?: number | null;
      created_at?: any | null;
      date: any;
      id: any;
      updated_at?: any | null;
      variant_id?: any | null;
      views?: number | null;
    }>;
  } | null;
};

export type CreateManyAddressVariables = Exact<{
  objects: Array<AddressesInsertInput> | AddressesInsertInput;
  on_conflict?: InputMaybe<AddressesOnConflict>;
}>;

export type CreateManyAddressResponse = {
  __typename?: "mutation_root";
  insert_addresses?: {
    __typename?: "addresses_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
      city: {
        __typename?: "cities";
        country_id: number;
        id: number;
        name: string;
        state?: string | null;
      };
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      country: {
        __typename?: "countries";
        code: string;
        code_3?: string | null;
        id: number;
        name: string;
      };
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneAddressVariables = Exact<{
  object: AddressesInsertInput;
  on_conflict?: InputMaybe<AddressesOnConflict>;
}>;

export type CreateOneAddressResponse = {
  __typename?: "mutation_root";
  insert_addresses_one?: {
    __typename?: "addresses";
    address_type?: any | null;
    city_id: number;
    company_id?: any | null;
    country_id: number;
    created_at?: any | null;
    id: number;
    is_primary?: boolean | null;
    name?: string | null;
    street1: string;
    street2?: string | null;
    updated_at?: any | null;
    user_id?: any | null;
    city: {
      __typename?: "cities";
      country_id: number;
      id: number;
      name: string;
      state?: string | null;
    };
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    country: {
      __typename?: "countries";
      code: string;
      code_3?: string | null;
      id: number;
      name: string;
    };
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type CreateManyAdVariables = Exact<{
  objects: Array<AdsInsertInput> | AdsInsertInput;
  on_conflict?: InputMaybe<AdsOnConflict>;
}>;

export type CreateManyAdResponse = {
  __typename?: "mutation_root";
  insert_ads?: {
    __typename?: "ads_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
      ad_package?: {
        __typename?: "ad_packages";
        active?: boolean | null;
        avg_roi?: any | null;
        created_at?: any | null;
        description: string;
        expected_ctr?: any | null;
        features: Array<string>;
        id: any;
        name: string;
        position: string;
        price: any;
        updated_at?: any | null;
        view_frequency?: any | null;
      } | null;
      ad_variants: Array<{
        __typename?: "ad_variants";
        active?: boolean | null;
        ad_id: any;
        content: any;
        created_at?: any | null;
        id: any;
        is_control?: boolean | null;
        performance_metrics?: any | null;
        updated_at?: any | null;
      }>;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null;
};

export type CreateOneAdVariables = Exact<{
  object: AdsInsertInput;
  on_conflict?: InputMaybe<AdsOnConflict>;
}>;

export type CreateOneAdResponse = {
  __typename?: "mutation_root";
  insert_ads_one?: {
    __typename?: "ads";
    active?: boolean | null;
    company_id?: any | null;
    created_at?: any | null;
    end_date: any;
    id: any;
    package_id?: any | null;
    start_date: any;
    updated_at?: any | null;
    ad_package?: {
      __typename?: "ad_packages";
      active?: boolean | null;
      avg_roi?: any | null;
      created_at?: any | null;
      description: string;
      expected_ctr?: any | null;
      features: Array<string>;
      id: any;
      name: string;
      position: string;
      price: any;
      updated_at?: any | null;
      view_frequency?: any | null;
    } | null;
    ad_variants: Array<{
      __typename?: "ad_variants";
      active?: boolean | null;
      ad_id: any;
      content: any;
      created_at?: any | null;
      id: any;
      is_control?: boolean | null;
      performance_metrics?: any | null;
      updated_at?: any | null;
    }>;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type CreateManyBlacklistedDomainVariables = Exact<{
  objects: Array<BlacklistedDomainsInsertInput> | BlacklistedDomainsInsertInput;
  on_conflict?: InputMaybe<BlacklistedDomainsOnConflict>;
}>;

export type CreateManyBlacklistedDomainResponse = {
  __typename?: "mutation_root";
  insert_blacklisted_domains?: {
    __typename?: "blacklisted_domains_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "blacklisted_domains";
      created_at: any;
      id: any;
      reason?: string | null;
      url: string;
    }>;
  } | null;
};

export type CreateOneBlacklistedDomainVariables = Exact<{
  object: BlacklistedDomainsInsertInput;
  on_conflict?: InputMaybe<BlacklistedDomainsOnConflict>;
}>;

export type CreateOneBlacklistedDomainResponse = {
  __typename?: "mutation_root";
  insert_blacklisted_domains_one?: {
    __typename?: "blacklisted_domains";
    created_at: any;
    id: any;
    reason?: string | null;
    url: string;
  } | null;
};

export type CreateManyBlacklistedUrlVariables = Exact<{
  objects: Array<BlacklistedUrlsInsertInput> | BlacklistedUrlsInsertInput;
  on_conflict?: InputMaybe<BlacklistedUrlsOnConflict>;
}>;

export type CreateManyBlacklistedUrlResponse = {
  __typename?: "mutation_root";
  insert_blacklisted_urls?: {
    __typename?: "blacklisted_urls_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "blacklisted_urls";
      company_id?: any | null;
      created_at?: any | null;
      id: number;
      reason?: string | null;
      url: string;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null;
};

export type CreateOneBlacklistedUrlVariables = Exact<{
  object: BlacklistedUrlsInsertInput;
  on_conflict?: InputMaybe<BlacklistedUrlsOnConflict>;
}>;

export type CreateOneBlacklistedUrlResponse = {
  __typename?: "mutation_root";
  insert_blacklisted_urls_one?: {
    __typename?: "blacklisted_urls";
    company_id?: any | null;
    created_at?: any | null;
    id: number;
    reason?: string | null;
    url: string;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type CreateManyBlockedIpVariables = Exact<{
  objects: Array<BlockedIpsInsertInput> | BlockedIpsInsertInput;
  on_conflict?: InputMaybe<BlockedIpsOnConflict>;
}>;

export type CreateManyBlockedIpResponse = {
  __typename?: "mutation_root";
  insert_blocked_ips?: {
    __typename?: "blocked_ips_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "blocked_ips";
      blocked_at?: any | null;
      blocked_until: any;
      created_at?: any | null;
      failed_attempts?: number | null;
      id: any;
      ip_address: any;
      reason?: string | null;
      updated_at?: any | null;
    }>;
  } | null;
};

export type CreateOneBlockedIpVariables = Exact<{
  object: BlockedIpsInsertInput;
  on_conflict?: InputMaybe<BlockedIpsOnConflict>;
}>;

export type CreateOneBlockedIpResponse = {
  __typename?: "mutation_root";
  insert_blocked_ips_one?: {
    __typename?: "blocked_ips";
    blocked_at?: any | null;
    blocked_until: any;
    created_at?: any | null;
    failed_attempts?: number | null;
    id: any;
    ip_address: any;
    reason?: string | null;
    updated_at?: any | null;
  } | null;
};

export type CreateManyBookmarkFolderVariables = Exact<{
  objects: Array<BookmarkFoldersInsertInput> | BookmarkFoldersInsertInput;
  on_conflict?: InputMaybe<BookmarkFoldersOnConflict>;
}>;

export type CreateManyBookmarkFolderResponse = {
  __typename?: "mutation_root";
  insert_bookmark_folders?: {
    __typename?: "bookmark_folders_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "bookmark_folders";
      color?: string | null;
      created_at?: any | null;
      id: any;
      is_default?: boolean | null;
      is_favorite?: boolean | null;
      name: string;
      parent_id?: any | null;
      path?: any | null;
      position?: number | null;
      updated_at?: any | null;
      user_id: any;
      bookmarks: Array<{
        __typename?: "bookmarks";
        content_id: any;
        content_type: string;
        created_at?: any | null;
        folder_id?: any | null;
        id: any;
        metadata?: any | null;
        updated_at?: any | null;
        user_id: any;
      }>;
    }>;
  } | null;
};

export type CreateOneBookmarkFolderVariables = Exact<{
  object: BookmarkFoldersInsertInput;
  on_conflict?: InputMaybe<BookmarkFoldersOnConflict>;
}>;

export type CreateOneBookmarkFolderResponse = {
  __typename?: "mutation_root";
  insert_bookmark_folders_one?: {
    __typename?: "bookmark_folders";
    color?: string | null;
    created_at?: any | null;
    id: any;
    is_default?: boolean | null;
    is_favorite?: boolean | null;
    name: string;
    parent_id?: any | null;
    path?: any | null;
    position?: number | null;
    updated_at?: any | null;
    user_id: any;
    bookmarks: Array<{
      __typename?: "bookmarks";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      folder_id?: any | null;
      id: any;
      metadata?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  } | null;
};

export type CreateManyBookmarkVariables = Exact<{
  objects: Array<BookmarksInsertInput> | BookmarksInsertInput;
  on_conflict?: InputMaybe<BookmarksOnConflict>;
}>;

export type CreateManyBookmarkResponse = {
  __typename?: "mutation_root";
  insert_bookmarks?: {
    __typename?: "bookmarks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "bookmarks";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      folder_id?: any | null;
      id: any;
      metadata?: any | null;
      updated_at?: any | null;
      user_id: any;
      bookmark_folder?: {
        __typename?: "bookmark_folders";
        color?: string | null;
        created_at?: any | null;
        id: any;
        is_default?: boolean | null;
        is_favorite?: boolean | null;
        name: string;
        parent_id?: any | null;
        path?: any | null;
        position?: number | null;
        updated_at?: any | null;
        user_id: any;
      } | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null;
};

export type CreateOneBookmarkVariables = Exact<{
  object: BookmarksInsertInput;
  on_conflict?: InputMaybe<BookmarksOnConflict>;
}>;

export type CreateOneBookmarkResponse = {
  __typename?: "mutation_root";
  insert_bookmarks_one?: {
    __typename?: "bookmarks";
    content_id: any;
    content_type: string;
    created_at?: any | null;
    folder_id?: any | null;
    id: any;
    metadata?: any | null;
    updated_at?: any | null;
    user_id: any;
    bookmark_folder?: {
      __typename?: "bookmark_folders";
      color?: string | null;
      created_at?: any | null;
      id: any;
      is_default?: boolean | null;
      is_favorite?: boolean | null;
      name: string;
      parent_id?: any | null;
      path?: any | null;
      position?: number | null;
      updated_at?: any | null;
      user_id: any;
    } | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type CreateManyBusinessDomainVariables = Exact<{
  objects: Array<BusinessDomainsInsertInput> | BusinessDomainsInsertInput;
  on_conflict?: InputMaybe<BusinessDomainsOnConflict>;
}>;

export type CreateManyBusinessDomainResponse = {
  __typename?: "mutation_root";
  insert_business_domains?: {
    __typename?: "business_domains_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "business_domains";
      created_at?: any | null;
      description?: string | null;
      id: any;
      name: string;
      parent_id?: any | null;
      slug: string;
      updated_at?: any | null;
      categorized_urls: Array<{
        __typename?: "categorized_urls";
        categorizer_version: string;
        company_id?: any | null;
        confidence: any;
        content_hash?: string | null;
        created_at?: any | null;
        domain_id: any;
        found_on?: string | null;
        id: any;
        priority?: any | null;
        updated_at?: any | null;
        url: string;
      }>;
    }>;
  } | null;
};

export type CreateOneBusinessDomainVariables = Exact<{
  object: BusinessDomainsInsertInput;
  on_conflict?: InputMaybe<BusinessDomainsOnConflict>;
}>;

export type CreateOneBusinessDomainResponse = {
  __typename?: "mutation_root";
  insert_business_domains_one?: {
    __typename?: "business_domains";
    created_at?: any | null;
    description?: string | null;
    id: any;
    name: string;
    parent_id?: any | null;
    slug: string;
    updated_at?: any | null;
    categorized_urls: Array<{
      __typename?: "categorized_urls";
      categorizer_version: string;
      company_id?: any | null;
      confidence: any;
      content_hash?: string | null;
      created_at?: any | null;
      domain_id: any;
      found_on?: string | null;
      id: any;
      priority?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
  } | null;
};

export type CreateManyCategoryVariables = Exact<{
  objects: Array<CategoriesInsertInput> | CategoriesInsertInput;
  on_conflict?: InputMaybe<CategoriesOnConflict>;
}>;

export type CreateManyCategoryResponse = {
  __typename?: "mutation_root";
  insert_categories?: {
    __typename?: "categories_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
      companies: Array<{
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      }>;
      content_categories: Array<{
        __typename?: "content_categories";
        category_id: any;
        content_id: any;
        is_primary: boolean;
      }>;
      feed_categories: Array<{
        __typename?: "feed_categories";
        category_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      news: Array<{
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      }>;
    }>;
  } | null;
};

export type CreateOneCategoryVariables = Exact<{
  object: CategoriesInsertInput;
  on_conflict?: InputMaybe<CategoriesOnConflict>;
}>;

export type CreateOneCategoryResponse = {
  __typename?: "mutation_root";
  insert_categories_one?: {
    __typename?: "categories";
    body?: string | null;
    created_at: any;
    document_id?: string | null;
    id: any;
    locale?: string | null;
    name: string;
    published_at?: string | null;
    updated_at?: any | null;
    companies: Array<{
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    }>;
    content_categories: Array<{
      __typename?: "content_categories";
      category_id: any;
      content_id: any;
      is_primary: boolean;
    }>;
    feed_categories: Array<{
      __typename?: "feed_categories";
      category_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    news: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
  } | null;
};

export type CreateManyCategorizedUrlVariables = Exact<{
  objects: Array<CategorizedUrlsInsertInput> | CategorizedUrlsInsertInput;
  on_conflict?: InputMaybe<CategorizedUrlsOnConflict>;
}>;

export type CreateManyCategorizedUrlResponse = {
  __typename?: "mutation_root";
  insert_categorized_urls?: {
    __typename?: "categorized_urls_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "categorized_urls";
      categorizer_version: string;
      company_id?: any | null;
      confidence: any;
      content_hash?: string | null;
      created_at?: any | null;
      domain_id: any;
      found_on?: string | null;
      id: any;
      priority?: any | null;
      updated_at?: any | null;
      url: string;
      business_domain: {
        __typename?: "business_domains";
        created_at?: any | null;
        description?: string | null;
        id: any;
        name: string;
        parent_id?: any | null;
        slug: string;
        updated_at?: any | null;
      };
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null;
};

export type CreateOneCategorizedUrlVariables = Exact<{
  object: CategorizedUrlsInsertInput;
  on_conflict?: InputMaybe<CategorizedUrlsOnConflict>;
}>;

export type CreateOneCategorizedUrlResponse = {
  __typename?: "mutation_root";
  insert_categorized_urls_one?: {
    __typename?: "categorized_urls";
    categorizer_version: string;
    company_id?: any | null;
    confidence: any;
    content_hash?: string | null;
    created_at?: any | null;
    domain_id: any;
    found_on?: string | null;
    id: any;
    priority?: any | null;
    updated_at?: any | null;
    url: string;
    business_domain: {
      __typename?: "business_domains";
      created_at?: any | null;
      description?: string | null;
      id: any;
      name: string;
      parent_id?: any | null;
      slug: string;
      updated_at?: any | null;
    };
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type CreateManyCircuitBreakerStateVariables = Exact<{
  objects:
    | Array<CircuitBreakerStatesInsertInput>
    | CircuitBreakerStatesInsertInput;
  on_conflict?: InputMaybe<CircuitBreakerStatesOnConflict>;
}>;

export type CreateManyCircuitBreakerStateResponse = {
  __typename?: "mutation_root";
  insert_circuit_breaker_states?: {
    __typename?: "circuit_breaker_states_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "circuit_breaker_states";
      created_at?: any | null;
      failure_count?: number | null;
      id: any;
      job_name: string;
      last_failure?: any | null;
      last_success?: any | null;
      state: string;
      updated_at?: any | null;
    }>;
  } | null;
};

export type CreateOneCircuitBreakerStateVariables = Exact<{
  object: CircuitBreakerStatesInsertInput;
  on_conflict?: InputMaybe<CircuitBreakerStatesOnConflict>;
}>;

export type CreateOneCircuitBreakerStateResponse = {
  __typename?: "mutation_root";
  insert_circuit_breaker_states_one?: {
    __typename?: "circuit_breaker_states";
    created_at?: any | null;
    failure_count?: number | null;
    id: any;
    job_name: string;
    last_failure?: any | null;
    last_success?: any | null;
    state: string;
    updated_at?: any | null;
  } | null;
};

export type CreateManyCityVariables = Exact<{
  objects: Array<CitiesInsertInput> | CitiesInsertInput;
  on_conflict?: InputMaybe<CitiesOnConflict>;
}>;

export type CreateManyCityResponse = {
  __typename?: "mutation_root";
  insert_cities?: {
    __typename?: "cities_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "cities";
      country_id: number;
      id: number;
      name: string;
      state?: string | null;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      country: {
        __typename?: "countries";
        code: string;
        code_3?: string | null;
        id: number;
        name: string;
      };
    }>;
  } | null;
};

export type CreateOneCityVariables = Exact<{
  object: CitiesInsertInput;
  on_conflict?: InputMaybe<CitiesOnConflict>;
}>;

export type CreateOneCityResponse = {
  __typename?: "mutation_root";
  insert_cities_one?: {
    __typename?: "cities";
    country_id: number;
    id: number;
    name: string;
    state?: string | null;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    country: {
      __typename?: "countries";
      code: string;
      code_3?: string | null;
      id: number;
      name: string;
    };
  } | null;
};

export type CreateManyCommentVariables = Exact<{
  objects: Array<CommentsInsertInput> | CommentsInsertInput;
  on_conflict?: InputMaybe<CommentsOnConflict>;
}>;

export type CreateManyCommentResponse = {
  __typename?: "mutation_root";
  insert_comments?: {
    __typename?: "comments_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "comments";
      content: string;
      content_id: any;
      content_type: any;
      created_at?: any | null;
      id: any;
      parent_comment_id?: any | null;
      updated_at?: any | null;
      user_id: any;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneCommentVariables = Exact<{
  object: CommentsInsertInput;
  on_conflict?: InputMaybe<CommentsOnConflict>;
}>;

export type CreateOneCommentResponse = {
  __typename?: "mutation_root";
  insert_comments_one?: {
    __typename?: "comments";
    content: string;
    content_id: any;
    content_type: any;
    created_at?: any | null;
    id: any;
    parent_comment_id?: any | null;
    updated_at?: any | null;
    user_id: any;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type CreateManyCompanyVariables = Exact<{
  objects: Array<CompaniesInsertInput> | CompaniesInsertInput;
  on_conflict?: InputMaybe<CompaniesOnConflict>;
}>;

export type CreateManyCompanyResponse = {
  __typename?: "mutation_root";
  insert_companies?: {
    __typename?: "companies_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      ads: Array<{
        __typename?: "ads";
        active?: boolean | null;
        company_id?: any | null;
        created_at?: any | null;
        end_date: any;
        id: any;
        package_id?: any | null;
        start_date: any;
        updated_at?: any | null;
      }>;
      blacklisted_urls: Array<{
        __typename?: "blacklisted_urls";
        company_id?: any | null;
        created_at?: any | null;
        id: number;
        reason?: string | null;
        url: string;
      }>;
      categorized_urls: Array<{
        __typename?: "categorized_urls";
        categorizer_version: string;
        company_id?: any | null;
        confidence: any;
        content_hash?: string | null;
        created_at?: any | null;
        domain_id: any;
        found_on?: string | null;
        id: any;
        priority?: any | null;
        updated_at?: any | null;
        url: string;
      }>;
      categoryByCategoryId?: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      } | null;
      company_contacts: Array<{
        __typename?: "company_contacts";
        company_id?: any | null;
        contact_id: number;
        created_at: any;
        id: number;
        updated_at: any;
      }>;
      company_extras: Array<{
        __typename?: "company_extras";
        body?: string | null;
        category: string;
        company_id?: any | null;
        created_at: any;
        found_count?: number | null;
        id: number;
        level: any;
        review?: any | null;
        success?: boolean | null;
        updated_at: any;
        url: string;
      }>;
      contacts: Array<{
        __typename?: "contacts";
        company_id?: any | null;
        contact_type?: any | null;
        created_at?: any | null;
        email?: string | null;
        id: number;
        is_primary?: boolean | null;
        phone?: string | null;
        privacy_level?: any | null;
        title?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      content_sources: Array<{
        __typename?: "content_sources";
        company_id?: any | null;
        content_type: any;
        created_at?: any | null;
        expected_count?: any | null;
        failed_count?: any | null;
        has_failed?: boolean | null;
        hash?: any | null;
        id: any;
        priority: any;
        refreshed_at?: any | null;
        rss_urls?: Array<string> | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        updated_at?: any | null;
        url: string;
      }>;
      news: Array<{
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      }>;
      social_medium?: {
        __typename?: "social_media";
        created_at?: any | null;
        facebook_url?: string | null;
        id: number;
        instagram_url?: string | null;
        linkedin_url?: string | null;
        twitter_url?: string | null;
        updated_at?: any | null;
        youtube_url?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneCompanyVariables = Exact<{
  object: CompaniesInsertInput;
  on_conflict?: InputMaybe<CompaniesOnConflict>;
}>;

export type CreateOneCompanyResponse = {
  __typename?: "mutation_root";
  insert_companies_one?: {
    __typename?: "companies";
    category?: string | null;
    category_id?: any | null;
    content_status: any;
    created_at?: any | null;
    description?: string | null;
    failed_count?: any | null;
    founding_year?: any | null;
    id: any;
    is_english?: boolean | null;
    is_government?: boolean | null;
    keywords?: any | null;
    logo_url?: string | null;
    name?: string | null;
    scrape_frequency?: any | null;
    scrape_rating?: any | null;
    scraped_at?: any | null;
    social_media_id?: number | null;
    updated_at?: any | null;
    url: string;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    ads: Array<{
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    }>;
    blacklisted_urls: Array<{
      __typename?: "blacklisted_urls";
      company_id?: any | null;
      created_at?: any | null;
      id: number;
      reason?: string | null;
      url: string;
    }>;
    categorized_urls: Array<{
      __typename?: "categorized_urls";
      categorizer_version: string;
      company_id?: any | null;
      confidence: any;
      content_hash?: string | null;
      created_at?: any | null;
      domain_id: any;
      found_on?: string | null;
      id: any;
      priority?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
    categoryByCategoryId?: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    } | null;
    company_contacts: Array<{
      __typename?: "company_contacts";
      company_id?: any | null;
      contact_id: number;
      created_at: any;
      id: number;
      updated_at: any;
    }>;
    company_extras: Array<{
      __typename?: "company_extras";
      body?: string | null;
      category: string;
      company_id?: any | null;
      created_at: any;
      found_count?: number | null;
      id: number;
      level: any;
      review?: any | null;
      success?: boolean | null;
      updated_at: any;
      url: string;
    }>;
    contacts: Array<{
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    content_sources: Array<{
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
    news: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
    social_medium?: {
      __typename?: "social_media";
      created_at?: any | null;
      facebook_url?: string | null;
      id: number;
      instagram_url?: string | null;
      linkedin_url?: string | null;
      twitter_url?: string | null;
      updated_at?: any | null;
      youtube_url?: string | null;
    } | null;
  } | null;
};

export type CreateManyCompanyContactVariables = Exact<{
  objects: Array<CompanyContactsInsertInput> | CompanyContactsInsertInput;
  on_conflict?: InputMaybe<CompanyContactsOnConflict>;
}>;

export type CreateManyCompanyContactResponse = {
  __typename?: "mutation_root";
  insert_company_contacts?: {
    __typename?: "company_contacts_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_contacts";
      company_id?: any | null;
      contact_id: number;
      created_at: any;
      id: number;
      updated_at: any;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      contact: {
        __typename?: "contacts";
        company_id?: any | null;
        contact_type?: any | null;
        created_at?: any | null;
        email?: string | null;
        id: number;
        is_primary?: boolean | null;
        phone?: string | null;
        privacy_level?: any | null;
        title?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      };
    }>;
  } | null;
};

export type CreateOneCompanyContactVariables = Exact<{
  object: CompanyContactsInsertInput;
  on_conflict?: InputMaybe<CompanyContactsOnConflict>;
}>;

export type CreateOneCompanyContactResponse = {
  __typename?: "mutation_root";
  insert_company_contacts_one?: {
    __typename?: "company_contacts";
    company_id?: any | null;
    contact_id: number;
    created_at: any;
    id: number;
    updated_at: any;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    contact: {
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    };
  } | null;
};

export type CreateManyCompanyEmployeeVariables = Exact<{
  objects: Array<CompanyEmployeesInsertInput> | CompanyEmployeesInsertInput;
  on_conflict?: InputMaybe<CompanyEmployeesOnConflict>;
}>;

export type CreateManyCompanyEmployeeResponse = {
  __typename?: "mutation_root";
  insert_company_employees?: {
    __typename?: "company_employees_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_employees";
      access_level: any;
      company_id?: any | null;
      created_at?: any | null;
      end_date?: any | null;
      id: any;
      job_description?: string | null;
      role: string;
      start_date?: any | null;
      status?: boolean | null;
      updated_at?: any | null;
      user_id: any;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneCompanyEmployeeVariables = Exact<{
  object: CompanyEmployeesInsertInput;
  on_conflict?: InputMaybe<CompanyEmployeesOnConflict>;
}>;

export type CreateOneCompanyEmployeeResponse = {
  __typename?: "mutation_root";
  insert_company_employees_one?: {
    __typename?: "company_employees";
    access_level: any;
    company_id?: any | null;
    created_at?: any | null;
    end_date?: any | null;
    id: any;
    job_description?: string | null;
    role: string;
    start_date?: any | null;
    status?: boolean | null;
    updated_at?: any | null;
    user_id: any;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type CreateManyCompanyExtraVariables = Exact<{
  objects: Array<CompanyExtrasInsertInput> | CompanyExtrasInsertInput;
  on_conflict?: InputMaybe<CompanyExtrasOnConflict>;
}>;

export type CreateManyCompanyExtraResponse = {
  __typename?: "mutation_root";
  insert_company_extras?: {
    __typename?: "company_extras_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_extras";
      body?: string | null;
      category: string;
      company_id?: any | null;
      created_at: any;
      found_count?: number | null;
      id: number;
      level: any;
      review?: any | null;
      success?: boolean | null;
      updated_at: any;
      url: string;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null;
};

export type CreateOneCompanyExtraVariables = Exact<{
  object: CompanyExtrasInsertInput;
  on_conflict?: InputMaybe<CompanyExtrasOnConflict>;
}>;

export type CreateOneCompanyExtraResponse = {
  __typename?: "mutation_root";
  insert_company_extras_one?: {
    __typename?: "company_extras";
    body?: string | null;
    category: string;
    company_id?: any | null;
    created_at: any;
    found_count?: number | null;
    id: number;
    level: any;
    review?: any | null;
    success?: boolean | null;
    updated_at: any;
    url: string;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type CreateManyCompanyMetricVariables = Exact<{
  objects: Array<CompanyMetricsInsertInput> | CompanyMetricsInsertInput;
  on_conflict?: InputMaybe<CompanyMetricsOnConflict>;
}>;

export type CreateManyCompanyMetricResponse = {
  __typename?: "mutation_root";
  insert_company_metrics?: {
    __typename?: "company_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_metrics";
      company_id: any;
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
      metric_definition?: {
        __typename?: "metric_definitions";
        category?: string | null;
        description?: string | null;
        id: number;
        is_dimensional?: boolean | null;
        name: string;
        type: string;
        unit?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneCompanyMetricVariables = Exact<{
  object: CompanyMetricsInsertInput;
  on_conflict?: InputMaybe<CompanyMetricsOnConflict>;
}>;

export type CreateOneCompanyMetricResponse = {
  __typename?: "mutation_root";
  insert_company_metrics_one?: {
    __typename?: "company_metrics";
    company_id: any;
    crawl_id: any;
    id: any;
    metric_id?: number | null;
    timestamp: any;
    value: any;
    metric_definition?: {
      __typename?: "metric_definitions";
      category?: string | null;
      description?: string | null;
      id: number;
      is_dimensional?: boolean | null;
      name: string;
      type: string;
      unit?: string | null;
    } | null;
  } | null;
};

export type CreateManyContactVariables = Exact<{
  objects: Array<ContactsInsertInput> | ContactsInsertInput;
  on_conflict?: InputMaybe<ContactsOnConflict>;
}>;

export type CreateManyContactResponse = {
  __typename?: "mutation_root";
  insert_contacts?: {
    __typename?: "contacts_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      company_contacts: Array<{
        __typename?: "company_contacts";
        company_id?: any | null;
        contact_id: number;
        created_at: any;
        id: number;
        updated_at: any;
      }>;
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneContactVariables = Exact<{
  object: ContactsInsertInput;
  on_conflict?: InputMaybe<ContactsOnConflict>;
}>;

export type CreateOneContactResponse = {
  __typename?: "mutation_root";
  insert_contacts_one?: {
    __typename?: "contacts";
    company_id?: any | null;
    contact_type?: any | null;
    created_at?: any | null;
    email?: string | null;
    id: number;
    is_primary?: boolean | null;
    phone?: string | null;
    privacy_level?: any | null;
    title?: string | null;
    updated_at?: any | null;
    user_id?: any | null;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    company_contacts: Array<{
      __typename?: "company_contacts";
      company_id?: any | null;
      contact_id: number;
      created_at: any;
      id: number;
      updated_at: any;
    }>;
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type CreateManyContentCategoryVariables = Exact<{
  objects: Array<ContentCategoriesInsertInput> | ContentCategoriesInsertInput;
  on_conflict?: InputMaybe<ContentCategoriesOnConflict>;
}>;

export type CreateManyContentCategoryResponse = {
  __typename?: "mutation_root";
  insert_content_categories?: {
    __typename?: "content_categories_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_categories";
      category_id: any;
      content_id: any;
      is_primary: boolean;
      category: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      };
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null;
};

export type CreateOneContentCategoryVariables = Exact<{
  object: ContentCategoriesInsertInput;
  on_conflict?: InputMaybe<ContentCategoriesOnConflict>;
}>;

export type CreateOneContentCategoryResponse = {
  __typename?: "mutation_root";
  insert_content_categories_one?: {
    __typename?: "content_categories";
    category_id: any;
    content_id: any;
    is_primary: boolean;
    category: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    };
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type CreateManyContentSourceVisitVariables = Exact<{
  objects:
    | Array<ContentSourceVisitsInsertInput>
    | ContentSourceVisitsInsertInput;
  on_conflict?: InputMaybe<ContentSourceVisitsOnConflict>;
}>;

export type CreateManyContentSourceVisitResponse = {
  __typename?: "mutation_root";
  insert_content_source_visits?: {
    __typename?: "content_source_visits_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_source_visits";
      content_id: any;
      created_at?: any | null;
      id: any;
      user_id?: any | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneContentSourceVisitVariables = Exact<{
  object: ContentSourceVisitsInsertInput;
  on_conflict?: InputMaybe<ContentSourceVisitsOnConflict>;
}>;

export type CreateOneContentSourceVisitResponse = {
  __typename?: "mutation_root";
  insert_content_source_visits_one?: {
    __typename?: "content_source_visits";
    content_id: any;
    created_at?: any | null;
    id: any;
    user_id?: any | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type CreateManyContentSourceVariables = Exact<{
  objects: Array<ContentSourcesInsertInput> | ContentSourcesInsertInput;
  on_conflict?: InputMaybe<ContentSourcesOnConflict>;
}>;

export type CreateManyContentSourceResponse = {
  __typename?: "mutation_root";
  insert_content_sources?: {
    __typename?: "content_sources_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      feed_sources: Array<{
        __typename?: "feed_sources";
        content_source_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      news: Array<{
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      }>;
    }>;
  } | null;
};

export type CreateOneContentSourceVariables = Exact<{
  object: ContentSourcesInsertInput;
  on_conflict?: InputMaybe<ContentSourcesOnConflict>;
}>;

export type CreateOneContentSourceResponse = {
  __typename?: "mutation_root";
  insert_content_sources_one?: {
    __typename?: "content_sources";
    company_id?: any | null;
    content_type: any;
    created_at?: any | null;
    expected_count?: any | null;
    failed_count?: any | null;
    has_failed?: boolean | null;
    hash?: any | null;
    id: any;
    priority: any;
    refreshed_at?: any | null;
    rss_urls?: Array<string> | null;
    scrape_frequency: any;
    scraped_at?: any | null;
    updated_at?: any | null;
    url: string;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    feed_sources: Array<{
      __typename?: "feed_sources";
      content_source_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    news: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
  } | null;
};

export type CreateManyContentStatusVariables = Exact<{
  objects: Array<ContentStatusesInsertInput> | ContentStatusesInsertInput;
  on_conflict?: InputMaybe<ContentStatusesOnConflict>;
}>;

export type CreateManyContentStatusResponse = {
  __typename?: "mutation_root";
  insert_content_statuses?: {
    __typename?: "content_statuses_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_statuses";
      content_id: any;
      content_status: any;
      created_at?: any | null;
      id: any;
      notes?: string | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null;
};

export type CreateOneContentStatusVariables = Exact<{
  object: ContentStatusesInsertInput;
  on_conflict?: InputMaybe<ContentStatusesOnConflict>;
}>;

export type CreateOneContentStatusResponse = {
  __typename?: "mutation_root";
  insert_content_statuses_one?: {
    __typename?: "content_statuses";
    content_id: any;
    content_status: any;
    created_at?: any | null;
    id: any;
    notes?: string | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type CreateManyContentTagVariables = Exact<{
  objects: Array<ContentTagsInsertInput> | ContentTagsInsertInput;
  on_conflict?: InputMaybe<ContentTagsOnConflict>;
}>;

export type CreateManyContentTagResponse = {
  __typename?: "mutation_root";
  insert_content_tags?: {
    __typename?: "content_tags_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_tags";
      content_id: any;
      tag_id: number;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      tag: {
        __typename?: "tags";
        body?: string | null;
        created_at?: any | null;
        document_id?: string | null;
        id: number;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      };
    }>;
  } | null;
};

export type CreateOneContentTagVariables = Exact<{
  object: ContentTagsInsertInput;
  on_conflict?: InputMaybe<ContentTagsOnConflict>;
}>;

export type CreateOneContentTagResponse = {
  __typename?: "mutation_root";
  insert_content_tags_one?: {
    __typename?: "content_tags";
    content_id: any;
    tag_id: number;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    tag: {
      __typename?: "tags";
      body?: string | null;
      created_at?: any | null;
      document_id?: string | null;
      id: number;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    };
  } | null;
};

export type CreateManyContentVariables = Exact<{
  objects: Array<ContentsInsertInput> | ContentsInsertInput;
  on_conflict?: InputMaybe<ContentsOnConflict>;
}>;

export type CreateManyContentResponse = {
  __typename?: "mutation_root";
  insert_contents?: {
    __typename?: "contents_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
      bookmarks: Array<{
        __typename?: "bookmarks";
        content_id: any;
        content_type: string;
        created_at?: any | null;
        folder_id?: any | null;
        id: any;
        metadata?: any | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      content_categories: Array<{
        __typename?: "content_categories";
        category_id: any;
        content_id: any;
        is_primary: boolean;
      }>;
      content_source_visits: Array<{
        __typename?: "content_source_visits";
        content_id: any;
        created_at?: any | null;
        id: any;
        user_id?: any | null;
      }>;
      content_statuses: Array<{
        __typename?: "content_statuses";
        content_id: any;
        content_status: any;
        created_at?: any | null;
        id: any;
        notes?: string | null;
      }>;
      content_tags: Array<{
        __typename?: "content_tags";
        content_id: any;
        tag_id: number;
      }>;
      news?: {
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      } | null;
      newsletter?: {
        __typename?: "newsletters";
        content_status: any;
        created_at?: any | null;
        end_date: any;
        frequency: string;
        generated_content?: string | null;
        id: any;
        start_date: any;
        title: string;
        updated_at?: any | null;
      } | null;
      research?: {
        __typename?: "research";
        abstract?: string | null;
        abstract_url: string;
        affiliations?: any | null;
        authors?: any | null;
        category?: string | null;
        comments?: string | null;
        content_status: any;
        created_at: any;
        doi_url?: string | null;
        figure_count?: any | null;
        has_embedding?: boolean | null;
        id: any;
        is_flagged: boolean;
        keywords?: string | null;
        month?: string | null;
        page_count?: any | null;
        pdf_url?: string | null;
        published_at?: any | null;
        published_in?: string | null;
        summary?: string | null;
        table_count?: any | null;
        title?: string | null;
        updated_at?: any | null;
        version?: any | null;
        year?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneContentVariables = Exact<{
  object: ContentsInsertInput;
  on_conflict?: InputMaybe<ContentsOnConflict>;
}>;

export type CreateOneContentResponse = {
  __typename?: "mutation_root";
  insert_contents_one?: {
    __typename?: "contents";
    content_type: any;
    created_at?: any | null;
    hot_score?: any | null;
    id: any;
    rss_url?: string | null;
    title?: string | null;
    updated_at?: any | null;
    url: string;
    bookmarks: Array<{
      __typename?: "bookmarks";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      folder_id?: any | null;
      id: any;
      metadata?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    content_categories: Array<{
      __typename?: "content_categories";
      category_id: any;
      content_id: any;
      is_primary: boolean;
    }>;
    content_source_visits: Array<{
      __typename?: "content_source_visits";
      content_id: any;
      created_at?: any | null;
      id: any;
      user_id?: any | null;
    }>;
    content_statuses: Array<{
      __typename?: "content_statuses";
      content_id: any;
      content_status: any;
      created_at?: any | null;
      id: any;
      notes?: string | null;
    }>;
    content_tags: Array<{
      __typename?: "content_tags";
      content_id: any;
      tag_id: number;
    }>;
    news?: {
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    } | null;
    newsletter?: {
      __typename?: "newsletters";
      content_status: any;
      created_at?: any | null;
      end_date: any;
      frequency: string;
      generated_content?: string | null;
      id: any;
      start_date: any;
      title: string;
      updated_at?: any | null;
    } | null;
    research?: {
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
    } | null;
  } | null;
};

export type CreateManyCountryVariables = Exact<{
  objects: Array<CountriesInsertInput> | CountriesInsertInput;
  on_conflict?: InputMaybe<CountriesOnConflict>;
}>;

export type CreateManyCountryResponse = {
  __typename?: "mutation_root";
  insert_countries?: {
    __typename?: "countries_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "countries";
      code: string;
      code_3?: string | null;
      id: number;
      name: string;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      cities: Array<{
        __typename?: "cities";
        country_id: number;
        id: number;
        name: string;
        state?: string | null;
      }>;
    }>;
  } | null;
};

export type CreateOneCountryVariables = Exact<{
  object: CountriesInsertInput;
  on_conflict?: InputMaybe<CountriesOnConflict>;
}>;

export type CreateOneCountryResponse = {
  __typename?: "mutation_root";
  insert_countries_one?: {
    __typename?: "countries";
    code: string;
    code_3?: string | null;
    id: number;
    name: string;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    cities: Array<{
      __typename?: "cities";
      country_id: number;
      id: number;
      name: string;
      state?: string | null;
    }>;
  } | null;
};

export type CreateManyCustomerPaymentVariables = Exact<{
  objects: Array<CustomerPaymentsInsertInput> | CustomerPaymentsInsertInput;
  on_conflict?: InputMaybe<CustomerPaymentsOnConflict>;
}>;

export type CreateManyCustomerPaymentResponse = {
  __typename?: "mutation_root";
  insert_customer_payments?: {
    __typename?: "customer_payments_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
      customer_refunds: Array<{
        __typename?: "customer_refunds";
        acquirer_data?: any | null;
        amount: any;
        batch_id?: string | null;
        created_at?: any | null;
        currency?: string | null;
        external_refund_id: string;
        id: number;
        notes?: any | null;
        payment_id: number;
        receipt?: string | null;
        speed_processed?: string | null;
        speed_requested?: string | null;
        status: string;
      }>;
      customer_subscription?: {
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      } | null;
      payment_provider: {
        __typename?: "payment_providers";
        created_at?: any | null;
        id: number;
        is_active?: boolean | null;
        name: string;
        updated_at?: any | null;
      };
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneCustomerPaymentVariables = Exact<{
  object: CustomerPaymentsInsertInput;
  on_conflict?: InputMaybe<CustomerPaymentsOnConflict>;
}>;

export type CreateOneCustomerPaymentResponse = {
  __typename?: "mutation_root";
  insert_customer_payments_one?: {
    __typename?: "customer_payments";
    acquirer_data?: any | null;
    amount: any;
    amount_refunded?: any | null;
    amount_transferred?: any | null;
    bank?: string | null;
    captured?: boolean | null;
    created_at?: any | null;
    currency: string;
    description?: string | null;
    error_code?: string | null;
    error_description?: string | null;
    error_reason?: string | null;
    error_source?: string | null;
    error_step?: string | null;
    external_order_id?: string | null;
    external_payment_id: string;
    fee?: any | null;
    id: number;
    international?: boolean | null;
    invoice_id?: string | null;
    method?: string | null;
    notes?: any | null;
    order_id?: string | null;
    payment_provider_id: number;
    refund_status?: string | null;
    status: string;
    subscription_id?: number | null;
    tax?: any | null;
    user_id: any;
    vpa?: string | null;
    wallet?: string | null;
    customer_refunds: Array<{
      __typename?: "customer_refunds";
      acquirer_data?: any | null;
      amount: any;
      batch_id?: string | null;
      created_at?: any | null;
      currency?: string | null;
      external_refund_id: string;
      id: number;
      notes?: any | null;
      payment_id: number;
      receipt?: string | null;
      speed_processed?: string | null;
      speed_requested?: string | null;
      status: string;
    }>;
    customer_subscription?: {
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    } | null;
    payment_provider: {
      __typename?: "payment_providers";
      created_at?: any | null;
      id: number;
      is_active?: boolean | null;
      name: string;
      updated_at?: any | null;
    };
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type CreateManyCustomerProcessedWebhookVariables = Exact<{
  objects:
    | Array<CustomerProcessedWebhooksInsertInput>
    | CustomerProcessedWebhooksInsertInput;
  on_conflict?: InputMaybe<CustomerProcessedWebhooksOnConflict>;
}>;

export type CreateManyCustomerProcessedWebhookResponse = {
  __typename?: "mutation_root";
  insert_customer_processed_webhooks?: {
    __typename?: "customer_processed_webhooks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_processed_webhooks";
      event_id: string;
      event_type: string;
      id: number;
      processed_at: any;
    }>;
  } | null;
};

export type CreateOneCustomerProcessedWebhookVariables = Exact<{
  object: CustomerProcessedWebhooksInsertInput;
  on_conflict?: InputMaybe<CustomerProcessedWebhooksOnConflict>;
}>;

export type CreateOneCustomerProcessedWebhookResponse = {
  __typename?: "mutation_root";
  insert_customer_processed_webhooks_one?: {
    __typename?: "customer_processed_webhooks";
    event_id: string;
    event_type: string;
    id: number;
    processed_at: any;
  } | null;
};

export type CreateManyCustomerRefundVariables = Exact<{
  objects: Array<CustomerRefundsInsertInput> | CustomerRefundsInsertInput;
  on_conflict?: InputMaybe<CustomerRefundsOnConflict>;
}>;

export type CreateManyCustomerRefundResponse = {
  __typename?: "mutation_root";
  insert_customer_refunds?: {
    __typename?: "customer_refunds_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_refunds";
      acquirer_data?: any | null;
      amount: any;
      batch_id?: string | null;
      created_at?: any | null;
      currency?: string | null;
      external_refund_id: string;
      id: number;
      notes?: any | null;
      payment_id: number;
      receipt?: string | null;
      speed_processed?: string | null;
      speed_requested?: string | null;
      status: string;
      customer_payment: {
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneCustomerRefundVariables = Exact<{
  object: CustomerRefundsInsertInput;
  on_conflict?: InputMaybe<CustomerRefundsOnConflict>;
}>;

export type CreateOneCustomerRefundResponse = {
  __typename?: "mutation_root";
  insert_customer_refunds_one?: {
    __typename?: "customer_refunds";
    acquirer_data?: any | null;
    amount: any;
    batch_id?: string | null;
    created_at?: any | null;
    currency?: string | null;
    external_refund_id: string;
    id: number;
    notes?: any | null;
    payment_id: number;
    receipt?: string | null;
    speed_processed?: string | null;
    speed_requested?: string | null;
    status: string;
    customer_payment: {
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    };
  } | null;
};

export type CreateManyCustomerSubscriptionPlanVariables = Exact<{
  objects:
    | Array<CustomerSubscriptionPlansInsertInput>
    | CustomerSubscriptionPlansInsertInput;
  on_conflict?: InputMaybe<CustomerSubscriptionPlansOnConflict>;
}>;

export type CreateManyCustomerSubscriptionPlanResponse = {
  __typename?: "mutation_root";
  insert_customer_subscription_plans?: {
    __typename?: "customer_subscription_plans_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_subscription_plans";
      annual_amount: any;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      external_plan_id?: string | null;
      features?: any | null;
      id: number;
      interval: number;
      interval_type: string;
      is_active?: boolean | null;
      monthly_amount: any;
      name: string;
      updated_at?: any | null;
      customer_subscriptions: Array<{
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      }>;
    }>;
  } | null;
};

export type CreateOneCustomerSubscriptionPlanVariables = Exact<{
  object: CustomerSubscriptionPlansInsertInput;
  on_conflict?: InputMaybe<CustomerSubscriptionPlansOnConflict>;
}>;

export type CreateOneCustomerSubscriptionPlanResponse = {
  __typename?: "mutation_root";
  insert_customer_subscription_plans_one?: {
    __typename?: "customer_subscription_plans";
    annual_amount: any;
    created_at?: any | null;
    currency: string;
    description?: string | null;
    external_plan_id?: string | null;
    features?: any | null;
    id: number;
    interval: number;
    interval_type: string;
    is_active?: boolean | null;
    monthly_amount: any;
    name: string;
    updated_at?: any | null;
    customer_subscriptions: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  } | null;
};

export type CreateManyCustomerSubscriptionVariables = Exact<{
  objects:
    | Array<CustomerSubscriptionsInsertInput>
    | CustomerSubscriptionsInsertInput;
  on_conflict?: InputMaybe<CustomerSubscriptionsOnConflict>;
}>;

export type CreateManyCustomerSubscriptionResponse = {
  __typename?: "mutation_root";
  insert_customer_subscriptions?: {
    __typename?: "customer_subscriptions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
      customer_payments: Array<{
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      }>;
      customer_subscription_plan: {
        __typename?: "customer_subscription_plans";
        annual_amount: any;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        external_plan_id?: string | null;
        features?: any | null;
        id: number;
        interval: number;
        interval_type: string;
        is_active?: boolean | null;
        monthly_amount: any;
        name: string;
        updated_at?: any | null;
      };
      payment_provider: {
        __typename?: "payment_providers";
        created_at?: any | null;
        id: number;
        is_active?: boolean | null;
        name: string;
        updated_at?: any | null;
      };
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneCustomerSubscriptionVariables = Exact<{
  object: CustomerSubscriptionsInsertInput;
  on_conflict?: InputMaybe<CustomerSubscriptionsOnConflict>;
}>;

export type CreateOneCustomerSubscriptionResponse = {
  __typename?: "mutation_root";
  insert_customer_subscriptions_one?: {
    __typename?: "customer_subscriptions";
    auth_attempts?: number | null;
    cancel_at_period_end?: boolean | null;
    cancel_initiated_by?: string | null;
    change_scheduled_at?: any | null;
    charge_at?: any | null;
    created_at?: any | null;
    current_end: any;
    current_start: any;
    customer_notify?: boolean | null;
    end_at?: any | null;
    ended_at?: any | null;
    expire_by?: any | null;
    external_subscription_id: string;
    has_scheduled_changes?: boolean | null;
    id: number;
    notes?: any | null;
    offer_id?: string | null;
    paid_count?: number | null;
    pause_initiated_by?: string | null;
    payment_provider_id: number;
    plan_id: number;
    quantity?: number | null;
    remaining_count?: number | null;
    short_url?: string | null;
    source?: string | null;
    start_at?: any | null;
    status: string;
    total_count?: number | null;
    type?: number | null;
    updated_at?: any | null;
    user_id: any;
    customer_payments: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
    customer_subscription_plan: {
      __typename?: "customer_subscription_plans";
      annual_amount: any;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      external_plan_id?: string | null;
      features?: any | null;
      id: number;
      interval: number;
      interval_type: string;
      is_active?: boolean | null;
      monthly_amount: any;
      name: string;
      updated_at?: any | null;
    };
    payment_provider: {
      __typename?: "payment_providers";
      created_at?: any | null;
      id: number;
      is_active?: boolean | null;
      name: string;
      updated_at?: any | null;
    };
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type CreateManyEmbeddingReviewVariables = Exact<{
  objects: Array<EmbeddingReviewsInsertInput> | EmbeddingReviewsInsertInput;
  on_conflict?: InputMaybe<EmbeddingReviewsOnConflict>;
}>;

export type CreateManyEmbeddingReviewResponse = {
  __typename?: "mutation_root";
  insert_embedding_reviews?: {
    __typename?: "embedding_reviews_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "embedding_reviews";
      agent_review?: boolean | null;
      created_at: any;
      human_review?: boolean | null;
      id: any;
      notes?: string | null;
      updated_at?: any | null;
      research_embeddings: Array<{
        __typename?: "research_embeddings";
        chunk: string;
        created_at?: any | null;
        embedding?: any | null;
        embedding_review_id?: any | null;
        id: number;
        is_flagged?: boolean | null;
        research_id: any;
        updated_at: any;
        url?: string | null;
      }>;
    }>;
  } | null;
};

export type CreateOneEmbeddingReviewVariables = Exact<{
  object: EmbeddingReviewsInsertInput;
  on_conflict?: InputMaybe<EmbeddingReviewsOnConflict>;
}>;

export type CreateOneEmbeddingReviewResponse = {
  __typename?: "mutation_root";
  insert_embedding_reviews_one?: {
    __typename?: "embedding_reviews";
    agent_review?: boolean | null;
    created_at: any;
    human_review?: boolean | null;
    id: any;
    notes?: string | null;
    updated_at?: any | null;
    research_embeddings: Array<{
      __typename?: "research_embeddings";
      chunk: string;
      created_at?: any | null;
      embedding?: any | null;
      embedding_review_id?: any | null;
      id: number;
      is_flagged?: boolean | null;
      research_id: any;
      updated_at: any;
      url?: string | null;
    }>;
  } | null;
};

export type CreateManyErrorLogVariables = Exact<{
  objects: Array<ErrorLogsInsertInput> | ErrorLogsInsertInput;
  on_conflict?: InputMaybe<ErrorLogsOnConflict>;
}>;

export type CreateManyErrorLogResponse = {
  __typename?: "mutation_root";
  insert_error_logs?: {
    __typename?: "error_logs_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "error_logs";
      context?: any | null;
      correlation_id?: any | null;
      created_at?: any | null;
      domain?: string | null;
      environment: string;
      error_hash?: string | null;
      error_pattern?: string | null;
      error_type: any;
      frequency_data?: any | null;
      github_repo?: string | null;
      id: any;
      is_new_pattern?: boolean | null;
      message: string;
      metadata?: any | null;
      related_errors?: any | null;
      request_id?: any | null;
      service_name: string;
      severity: any;
      stack_trace?: string | null;
      user_id?: any | null;
    }>;
  } | null;
};

export type CreateOneErrorLogVariables = Exact<{
  object: ErrorLogsInsertInput;
  on_conflict?: InputMaybe<ErrorLogsOnConflict>;
}>;

export type CreateOneErrorLogResponse = {
  __typename?: "mutation_root";
  insert_error_logs_one?: {
    __typename?: "error_logs";
    context?: any | null;
    correlation_id?: any | null;
    created_at?: any | null;
    domain?: string | null;
    environment: string;
    error_hash?: string | null;
    error_pattern?: string | null;
    error_type: any;
    frequency_data?: any | null;
    github_repo?: string | null;
    id: any;
    is_new_pattern?: boolean | null;
    message: string;
    metadata?: any | null;
    related_errors?: any | null;
    request_id?: any | null;
    service_name: string;
    severity: any;
    stack_trace?: string | null;
    user_id?: any | null;
  } | null;
};

export type CreateManyFeatureRequestVariables = Exact<{
  objects: Array<FeatureRequestsInsertInput> | FeatureRequestsInsertInput;
  on_conflict?: InputMaybe<FeatureRequestsOnConflict>;
}>;

export type CreateManyFeatureRequestResponse = {
  __typename?: "mutation_root";
  insert_feature_requests?: {
    __typename?: "feature_requests_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feature_requests";
      created_at?: any | null;
      description?: string | null;
      downvotes?: number | null;
      engagement_score?: number | null;
      id: any;
      priority_score?: number | null;
      status: string;
      title: string;
      updated_at?: any | null;
      upvotes?: number | null;
      feature_votes: Array<{
        __typename?: "feature_votes";
        created_at?: any | null;
        feature_id: any;
        feedback?: string | null;
        id: any;
        updated_at?: any | null;
        user_id: any;
        vote_type: any;
      }>;
    }>;
  } | null;
};

export type CreateOneFeatureRequestVariables = Exact<{
  object: FeatureRequestsInsertInput;
  on_conflict?: InputMaybe<FeatureRequestsOnConflict>;
}>;

export type CreateOneFeatureRequestResponse = {
  __typename?: "mutation_root";
  insert_feature_requests_one?: {
    __typename?: "feature_requests";
    created_at?: any | null;
    description?: string | null;
    downvotes?: number | null;
    engagement_score?: number | null;
    id: any;
    priority_score?: number | null;
    status: string;
    title: string;
    updated_at?: any | null;
    upvotes?: number | null;
    feature_votes: Array<{
      __typename?: "feature_votes";
      created_at?: any | null;
      feature_id: any;
      feedback?: string | null;
      id: any;
      updated_at?: any | null;
      user_id: any;
      vote_type: any;
    }>;
  } | null;
};

export type CreateManyFeatureVoteVariables = Exact<{
  objects: Array<FeatureVotesInsertInput> | FeatureVotesInsertInput;
  on_conflict?: InputMaybe<FeatureVotesOnConflict>;
}>;

export type CreateManyFeatureVoteResponse = {
  __typename?: "mutation_root";
  insert_feature_votes?: {
    __typename?: "feature_votes_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feature_votes";
      created_at?: any | null;
      feature_id: any;
      feedback?: string | null;
      id: any;
      updated_at?: any | null;
      user_id: any;
      vote_type: any;
      feature_request: {
        __typename?: "feature_requests";
        created_at?: any | null;
        description?: string | null;
        downvotes?: number | null;
        engagement_score?: number | null;
        id: any;
        priority_score?: number | null;
        status: string;
        title: string;
        updated_at?: any | null;
        upvotes?: number | null;
      };
    }>;
  } | null;
};

export type CreateOneFeatureVoteVariables = Exact<{
  object: FeatureVotesInsertInput;
  on_conflict?: InputMaybe<FeatureVotesOnConflict>;
}>;

export type CreateOneFeatureVoteResponse = {
  __typename?: "mutation_root";
  insert_feature_votes_one?: {
    __typename?: "feature_votes";
    created_at?: any | null;
    feature_id: any;
    feedback?: string | null;
    id: any;
    updated_at?: any | null;
    user_id: any;
    vote_type: any;
    feature_request: {
      __typename?: "feature_requests";
      created_at?: any | null;
      description?: string | null;
      downvotes?: number | null;
      engagement_score?: number | null;
      id: any;
      priority_score?: number | null;
      status: string;
      title: string;
      updated_at?: any | null;
      upvotes?: number | null;
    };
  } | null;
};

export type CreateManyFeedCategoryVariables = Exact<{
  objects: Array<FeedCategoriesInsertInput> | FeedCategoriesInsertInput;
  on_conflict?: InputMaybe<FeedCategoriesOnConflict>;
}>;

export type CreateManyFeedCategoryResponse = {
  __typename?: "mutation_root";
  insert_feed_categories?: {
    __typename?: "feed_categories_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feed_categories";
      category_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
      category?: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      } | null;
      feed?: {
        __typename?: "feeds";
        created_at: any;
        id: any;
        name?: string | null;
        user_id?: any | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneFeedCategoryVariables = Exact<{
  object: FeedCategoriesInsertInput;
  on_conflict?: InputMaybe<FeedCategoriesOnConflict>;
}>;

export type CreateOneFeedCategoryResponse = {
  __typename?: "mutation_root";
  insert_feed_categories_one?: {
    __typename?: "feed_categories";
    category_id?: any | null;
    created_at: any;
    feed_id?: any | null;
    id: any;
    category?: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    } | null;
    feed?: {
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    } | null;
  } | null;
};

export type CreateManyFeedSourceVariables = Exact<{
  objects: Array<FeedSourcesInsertInput> | FeedSourcesInsertInput;
  on_conflict?: InputMaybe<FeedSourcesOnConflict>;
}>;

export type CreateManyFeedSourceResponse = {
  __typename?: "mutation_root";
  insert_feed_sources?: {
    __typename?: "feed_sources_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feed_sources";
      content_source_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
      content_source?: {
        __typename?: "content_sources";
        company_id?: any | null;
        content_type: any;
        created_at?: any | null;
        expected_count?: any | null;
        failed_count?: any | null;
        has_failed?: boolean | null;
        hash?: any | null;
        id: any;
        priority: any;
        refreshed_at?: any | null;
        rss_urls?: Array<string> | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        updated_at?: any | null;
        url: string;
      } | null;
      feed?: {
        __typename?: "feeds";
        created_at: any;
        id: any;
        name?: string | null;
        user_id?: any | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneFeedSourceVariables = Exact<{
  object: FeedSourcesInsertInput;
  on_conflict?: InputMaybe<FeedSourcesOnConflict>;
}>;

export type CreateOneFeedSourceResponse = {
  __typename?: "mutation_root";
  insert_feed_sources_one?: {
    __typename?: "feed_sources";
    content_source_id?: any | null;
    created_at: any;
    feed_id?: any | null;
    id: any;
    content_source?: {
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    } | null;
    feed?: {
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    } | null;
  } | null;
};

export type CreateManyFeedbackVariables = Exact<{
  objects: Array<FeedbacksInsertInput> | FeedbacksInsertInput;
  on_conflict?: InputMaybe<FeedbacksOnConflict>;
}>;

export type CreateManyFeedbackResponse = {
  __typename?: "mutation_root";
  insert_feedbacks?: {
    __typename?: "feedbacks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feedbacks";
      created_at: any;
      device_info?: string | null;
      feedback_status?: any | null;
      feedback_type?: any | null;
      id: number;
      message: string;
      page_identifier: string;
      rating?: number | null;
      resolution_comment?: string | null;
      updated_at: any;
      user_id?: any | null;
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneFeedbackVariables = Exact<{
  object: FeedbacksInsertInput;
  on_conflict?: InputMaybe<FeedbacksOnConflict>;
}>;

export type CreateOneFeedbackResponse = {
  __typename?: "mutation_root";
  insert_feedbacks_one?: {
    __typename?: "feedbacks";
    created_at: any;
    device_info?: string | null;
    feedback_status?: any | null;
    feedback_type?: any | null;
    id: number;
    message: string;
    page_identifier: string;
    rating?: number | null;
    resolution_comment?: string | null;
    updated_at: any;
    user_id?: any | null;
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type CreateManyFeedVariables = Exact<{
  objects: Array<FeedsInsertInput> | FeedsInsertInput;
  on_conflict?: InputMaybe<FeedsOnConflict>;
}>;

export type CreateManyFeedResponse = {
  __typename?: "mutation_root";
  insert_feeds?: {
    __typename?: "feeds_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
      feed_categories: Array<{
        __typename?: "feed_categories";
        category_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      feed_sources: Array<{
        __typename?: "feed_sources";
        content_source_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneFeedVariables = Exact<{
  object: FeedsInsertInput;
  on_conflict?: InputMaybe<FeedsOnConflict>;
}>;

export type CreateOneFeedResponse = {
  __typename?: "mutation_root";
  insert_feeds_one?: {
    __typename?: "feeds";
    created_at: any;
    id: any;
    name?: string | null;
    user_id?: any | null;
    feed_categories: Array<{
      __typename?: "feed_categories";
      category_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    feed_sources: Array<{
      __typename?: "feed_sources";
      content_source_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type CreateManyFollowVariables = Exact<{
  objects: Array<FollowsInsertInput> | FollowsInsertInput;
  on_conflict?: InputMaybe<FollowsOnConflict>;
}>;

export type CreateManyFollowResponse = {
  __typename?: "mutation_root";
  insert_follows?: {
    __typename?: "follows_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "follows";
      created_at?: any | null;
      followed_entity: any;
      followed_id: any;
      id: any;
      user_id: any;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneFollowVariables = Exact<{
  object: FollowsInsertInput;
  on_conflict?: InputMaybe<FollowsOnConflict>;
}>;

export type CreateOneFollowResponse = {
  __typename?: "mutation_root";
  insert_follows_one?: {
    __typename?: "follows";
    created_at?: any | null;
    followed_entity: any;
    followed_id: any;
    id: any;
    user_id: any;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type CreateManyMetricDefinitionVariables = Exact<{
  objects: Array<MetricDefinitionsInsertInput> | MetricDefinitionsInsertInput;
  on_conflict?: InputMaybe<MetricDefinitionsOnConflict>;
}>;

export type CreateManyMetricDefinitionResponse = {
  __typename?: "mutation_root";
  insert_metric_definitions?: {
    __typename?: "metric_definitions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "metric_definitions";
      category?: string | null;
      description?: string | null;
      id: number;
      is_dimensional?: boolean | null;
      name: string;
      type: string;
      unit?: string | null;
      company_metrics: Array<{
        __typename?: "company_metrics";
        company_id: any;
        crawl_id: any;
        id: any;
        metric_id?: number | null;
        timestamp: any;
        value: any;
      }>;
      spider_metrics: Array<{
        __typename?: "spider_metrics";
        crawl_id: any;
        id: any;
        metric_id?: number | null;
        timestamp: any;
        value: any;
      }>;
    }>;
  } | null;
};

export type CreateOneMetricDefinitionVariables = Exact<{
  object: MetricDefinitionsInsertInput;
  on_conflict?: InputMaybe<MetricDefinitionsOnConflict>;
}>;

export type CreateOneMetricDefinitionResponse = {
  __typename?: "mutation_root";
  insert_metric_definitions_one?: {
    __typename?: "metric_definitions";
    category?: string | null;
    description?: string | null;
    id: number;
    is_dimensional?: boolean | null;
    name: string;
    type: string;
    unit?: string | null;
    company_metrics: Array<{
      __typename?: "company_metrics";
      company_id: any;
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
    }>;
    spider_metrics: Array<{
      __typename?: "spider_metrics";
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
    }>;
  } | null;
};

export type CreateManyNewsVariables = Exact<{
  objects: Array<NewsInsertInput> | NewsInsertInput;
  on_conflict?: InputMaybe<NewsOnConflict>;
}>;

export type CreateManyNewsResponse = {
  __typename?: "mutation_root";
  insert_news?: {
    __typename?: "news_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
      category?: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      } | null;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      content_source?: {
        __typename?: "content_sources";
        company_id?: any | null;
        content_type: any;
        created_at?: any | null;
        expected_count?: any | null;
        failed_count?: any | null;
        has_failed?: boolean | null;
        hash?: any | null;
        id: any;
        priority: any;
        refreshed_at?: any | null;
        rss_urls?: Array<string> | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        updated_at?: any | null;
        url: string;
      } | null;
      news_summaries: Array<{
        __typename?: "news_summaries";
        complexity_level?: any | null;
        created_at?: any | null;
        embedding?: any | null;
        id: any;
        is_current?: boolean | null;
        news_id: any;
        summary?: string | null;
        updated_at?: any | null;
        version: number;
      }>;
    }>;
  } | null;
};

export type CreateOneNewsVariables = Exact<{
  object: NewsInsertInput;
  on_conflict?: InputMaybe<NewsOnConflict>;
}>;

export type CreateOneNewsResponse = {
  __typename?: "mutation_root";
  insert_news_one?: {
    __typename?: "news";
    author?: string | null;
    body?: string | null;
    category_id?: any | null;
    company_id?: any | null;
    content_source_id?: any | null;
    content_status: any;
    created_at: any;
    description?: string | null;
    failed_count?: any | null;
    featured_image?: string | null;
    has_summary: boolean;
    hash?: any | null;
    id: any;
    keywords?: any | null;
    published_at?: any | null;
    scrape_frequency: any;
    scraped_at?: any | null;
    title?: string | null;
    updated_at: any;
    url: string;
    category?: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    } | null;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    content_source?: {
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    } | null;
    news_summaries: Array<{
      __typename?: "news_summaries";
      complexity_level?: any | null;
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      is_current?: boolean | null;
      news_id: any;
      summary?: string | null;
      updated_at?: any | null;
      version: number;
    }>;
  } | null;
};

export type CreateManyNewsSummaryVariables = Exact<{
  objects: Array<NewsSummariesInsertInput> | NewsSummariesInsertInput;
  on_conflict?: InputMaybe<NewsSummariesOnConflict>;
}>;

export type CreateManyNewsSummaryResponse = {
  __typename?: "mutation_root";
  insert_news_summaries?: {
    __typename?: "news_summaries_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "news_summaries";
      complexity_level?: any | null;
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      is_current?: boolean | null;
      news_id: any;
      summary?: string | null;
      updated_at?: any | null;
      version: number;
      news: {
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      };
    }>;
  } | null;
};

export type CreateOneNewsSummaryVariables = Exact<{
  object: NewsSummariesInsertInput;
  on_conflict?: InputMaybe<NewsSummariesOnConflict>;
}>;

export type CreateOneNewsSummaryResponse = {
  __typename?: "mutation_root";
  insert_news_summaries_one?: {
    __typename?: "news_summaries";
    complexity_level?: any | null;
    created_at?: any | null;
    embedding?: any | null;
    id: any;
    is_current?: boolean | null;
    news_id: any;
    summary?: string | null;
    updated_at?: any | null;
    version: number;
    news: {
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    };
  } | null;
};

export type CreateManyNewsTagVariables = Exact<{
  objects: Array<NewsTagsInsertInput> | NewsTagsInsertInput;
  on_conflict?: InputMaybe<NewsTagsOnConflict>;
}>;

export type CreateManyNewsTagResponse = {
  __typename?: "mutation_root";
  insert_news_tags?: {
    __typename?: "news_tags_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "news_tags";
      id: number;
      news_id?: any | null;
      tag_id: number;
      tag: {
        __typename?: "tags";
        body?: string | null;
        created_at?: any | null;
        document_id?: string | null;
        id: number;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      };
    }>;
  } | null;
};

export type CreateOneNewsTagVariables = Exact<{
  object: NewsTagsInsertInput;
  on_conflict?: InputMaybe<NewsTagsOnConflict>;
}>;

export type CreateOneNewsTagResponse = {
  __typename?: "mutation_root";
  insert_news_tags_one?: {
    __typename?: "news_tags";
    id: number;
    news_id?: any | null;
    tag_id: number;
    tag: {
      __typename?: "tags";
      body?: string | null;
      created_at?: any | null;
      document_id?: string | null;
      id: number;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    };
  } | null;
};

export type CreateManyNewsletterVariables = Exact<{
  objects: Array<NewslettersInsertInput> | NewslettersInsertInput;
  on_conflict?: InputMaybe<NewslettersOnConflict>;
}>;

export type CreateManyNewsletterResponse = {
  __typename?: "mutation_root";
  insert_newsletters?: {
    __typename?: "newsletters_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "newsletters";
      content_status: any;
      created_at?: any | null;
      end_date: any;
      frequency: string;
      generated_content?: string | null;
      id: any;
      start_date: any;
      title: string;
      updated_at?: any | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null;
};

export type CreateOneNewsletterVariables = Exact<{
  object: NewslettersInsertInput;
  on_conflict?: InputMaybe<NewslettersOnConflict>;
}>;

export type CreateOneNewsletterResponse = {
  __typename?: "mutation_root";
  insert_newsletters_one?: {
    __typename?: "newsletters";
    content_status: any;
    created_at?: any | null;
    end_date: any;
    frequency: string;
    generated_content?: string | null;
    id: any;
    start_date: any;
    title: string;
    updated_at?: any | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type CreateManyPaymentProviderVariables = Exact<{
  objects: Array<PaymentProvidersInsertInput> | PaymentProvidersInsertInput;
  on_conflict?: InputMaybe<PaymentProvidersOnConflict>;
}>;

export type CreateManyPaymentProviderResponse = {
  __typename?: "mutation_root";
  insert_payment_providers?: {
    __typename?: "payment_providers_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "payment_providers";
      created_at?: any | null;
      id: number;
      is_active?: boolean | null;
      name: string;
      updated_at?: any | null;
      customer_payments: Array<{
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      }>;
      customer_subscriptions: Array<{
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      }>;
    }>;
  } | null;
};

export type CreateOnePaymentProviderVariables = Exact<{
  object: PaymentProvidersInsertInput;
  on_conflict?: InputMaybe<PaymentProvidersOnConflict>;
}>;

export type CreateOnePaymentProviderResponse = {
  __typename?: "mutation_root";
  insert_payment_providers_one?: {
    __typename?: "payment_providers";
    created_at?: any | null;
    id: number;
    is_active?: boolean | null;
    name: string;
    updated_at?: any | null;
    customer_payments: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
    customer_subscriptions: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  } | null;
};

export type CreateManyPlanPermissionVariables = Exact<{
  objects: Array<PlanPermissionsInsertInput> | PlanPermissionsInsertInput;
  on_conflict?: InputMaybe<PlanPermissionsOnConflict>;
}>;

export type CreateManyPlanPermissionResponse = {
  __typename?: "mutation_root";
  insert_plan_permissions?: {
    __typename?: "plan_permissions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "plan_permissions";
      feature: string;
      id: number;
      plan: any;
    }>;
  } | null;
};

export type CreateOnePlanPermissionVariables = Exact<{
  object: PlanPermissionsInsertInput;
  on_conflict?: InputMaybe<PlanPermissionsOnConflict>;
}>;

export type CreateOnePlanPermissionResponse = {
  __typename?: "mutation_root";
  insert_plan_permissions_one?: {
    __typename?: "plan_permissions";
    feature: string;
    id: number;
    plan: any;
  } | null;
};

export type CreateManyRecentErrorVariables = Exact<{
  objects: Array<RecentErrorsInsertInput> | RecentErrorsInsertInput;
}>;

export type CreateManyRecentErrorResponse = {
  __typename?: "mutation_root";
  insert_recent_errors?: {
    __typename?: "recent_errors_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "recent_errors";
      created_at?: any | null;
      error_type?: any | null;
      message?: string | null;
      metadata?: any | null;
      service_name?: string | null;
      severity?: any | null;
    }>;
  } | null;
};

export type CreateOneRecentErrorVariables = Exact<{
  object: RecentErrorsInsertInput;
}>;

export type CreateOneRecentErrorResponse = {
  __typename?: "mutation_root";
  insert_recent_errors_one?: {
    __typename?: "recent_errors";
    created_at?: any | null;
    error_type?: any | null;
    message?: string | null;
    metadata?: any | null;
    service_name?: string | null;
    severity?: any | null;
  } | null;
};

export type CreateManyReferralVariables = Exact<{
  objects: Array<ReferralsInsertInput> | ReferralsInsertInput;
  on_conflict?: InputMaybe<ReferralsOnConflict>;
}>;

export type CreateManyReferralResponse = {
  __typename?: "mutation_root";
  insert_referrals?: {
    __typename?: "referrals_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "referrals";
      browser?: string | null;
      client_fingerprint?: string | null;
      conversion_value?: any | null;
      converted_at?: any | null;
      country_code?: string | null;
      created_at?: any | null;
      device_type?: string | null;
      id: any;
      ip_address?: any | null;
      is_suspicious?: boolean | null;
      landing_page?: string | null;
      last_failed_attempt?: any | null;
      referral_status?: any | null;
      referrer_code: string;
      region?: string | null;
      security_flags?: any | null;
      user_agent?: string | null;
      utm_campaign?: string | null;
      utm_medium?: string | null;
      utm_source?: string | null;
      validation_attempts?: number | null;
      visitor_id: any;
    }>;
  } | null;
};

export type CreateOneReferralVariables = Exact<{
  object: ReferralsInsertInput;
  on_conflict?: InputMaybe<ReferralsOnConflict>;
}>;

export type CreateOneReferralResponse = {
  __typename?: "mutation_root";
  insert_referrals_one?: {
    __typename?: "referrals";
    browser?: string | null;
    client_fingerprint?: string | null;
    conversion_value?: any | null;
    converted_at?: any | null;
    country_code?: string | null;
    created_at?: any | null;
    device_type?: string | null;
    id: any;
    ip_address?: any | null;
    is_suspicious?: boolean | null;
    landing_page?: string | null;
    last_failed_attempt?: any | null;
    referral_status?: any | null;
    referrer_code: string;
    region?: string | null;
    security_flags?: any | null;
    user_agent?: string | null;
    utm_campaign?: string | null;
    utm_medium?: string | null;
    utm_source?: string | null;
    validation_attempts?: number | null;
    visitor_id: any;
  } | null;
};

export type CreateManyReferrerBlockVariables = Exact<{
  objects: Array<ReferrerBlocksInsertInput> | ReferrerBlocksInsertInput;
  on_conflict?: InputMaybe<ReferrerBlocksOnConflict>;
}>;

export type CreateManyReferrerBlockResponse = {
  __typename?: "mutation_root";
  insert_referrer_blocks?: {
    __typename?: "referrer_blocks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "referrer_blocks";
      blocked_at?: any | null;
      blocked_by: string;
      created_at?: any | null;
      id: any;
      is_permanent?: boolean | null;
      reason?: string | null;
      referrer_code: string;
      updated_at?: any | null;
    }>;
  } | null;
};

export type CreateOneReferrerBlockVariables = Exact<{
  object: ReferrerBlocksInsertInput;
  on_conflict?: InputMaybe<ReferrerBlocksOnConflict>;
}>;

export type CreateOneReferrerBlockResponse = {
  __typename?: "mutation_root";
  insert_referrer_blocks_one?: {
    __typename?: "referrer_blocks";
    blocked_at?: any | null;
    blocked_by: string;
    created_at?: any | null;
    id: any;
    is_permanent?: boolean | null;
    reason?: string | null;
    referrer_code: string;
    updated_at?: any | null;
  } | null;
};

export type CreateManyResearchVariables = Exact<{
  objects: Array<ResearchInsertInput> | ResearchInsertInput;
  on_conflict?: InputMaybe<ResearchOnConflict>;
}>;

export type CreateManyResearchResponse = {
  __typename?: "mutation_root";
  insert_research?: {
    __typename?: "research_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      research_embedding?: {
        __typename?: "research_embeddings";
        chunk: string;
        created_at?: any | null;
        embedding?: any | null;
        embedding_review_id?: any | null;
        id: number;
        is_flagged?: boolean | null;
        research_id: any;
        updated_at: any;
        url?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateManyResearchEmbeddingVariables = Exact<{
  objects: Array<ResearchEmbeddingsInsertInput> | ResearchEmbeddingsInsertInput;
  on_conflict?: InputMaybe<ResearchEmbeddingsOnConflict>;
}>;

export type CreateManyResearchEmbeddingResponse = {
  __typename?: "mutation_root";
  insert_research_embeddings?: {
    __typename?: "research_embeddings_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "research_embeddings";
      chunk: string;
      created_at?: any | null;
      embedding?: any | null;
      embedding_review_id?: any | null;
      id: number;
      is_flagged?: boolean | null;
      research_id: any;
      updated_at: any;
      url?: string | null;
      embedding_review?: {
        __typename?: "embedding_reviews";
        agent_review?: boolean | null;
        created_at: any;
        human_review?: boolean | null;
        id: any;
        notes?: string | null;
        updated_at?: any | null;
      } | null;
      research: {
        __typename?: "research";
        abstract?: string | null;
        abstract_url: string;
        affiliations?: any | null;
        authors?: any | null;
        category?: string | null;
        comments?: string | null;
        content_status: any;
        created_at: any;
        doi_url?: string | null;
        figure_count?: any | null;
        has_embedding?: boolean | null;
        id: any;
        is_flagged: boolean;
        keywords?: string | null;
        month?: string | null;
        page_count?: any | null;
        pdf_url?: string | null;
        published_at?: any | null;
        published_in?: string | null;
        summary?: string | null;
        table_count?: any | null;
        title?: string | null;
        updated_at?: any | null;
        version?: any | null;
        year?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneResearchEmbeddingVariables = Exact<{
  object: ResearchEmbeddingsInsertInput;
  on_conflict?: InputMaybe<ResearchEmbeddingsOnConflict>;
}>;

export type CreateOneResearchEmbeddingResponse = {
  __typename?: "mutation_root";
  insert_research_embeddings_one?: {
    __typename?: "research_embeddings";
    chunk: string;
    created_at?: any | null;
    embedding?: any | null;
    embedding_review_id?: any | null;
    id: number;
    is_flagged?: boolean | null;
    research_id: any;
    updated_at: any;
    url?: string | null;
    embedding_review?: {
      __typename?: "embedding_reviews";
      agent_review?: boolean | null;
      created_at: any;
      human_review?: boolean | null;
      id: any;
      notes?: string | null;
      updated_at?: any | null;
    } | null;
    research: {
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
    };
  } | null;
};

export type CreateOneResearchVariables = Exact<{
  object: ResearchInsertInput;
  on_conflict?: InputMaybe<ResearchOnConflict>;
}>;

export type CreateOneResearchResponse = {
  __typename?: "mutation_root";
  insert_research_one?: {
    __typename?: "research";
    abstract?: string | null;
    abstract_url: string;
    affiliations?: any | null;
    authors?: any | null;
    category?: string | null;
    comments?: string | null;
    content_status: any;
    created_at: any;
    doi_url?: string | null;
    figure_count?: any | null;
    has_embedding?: boolean | null;
    id: any;
    is_flagged: boolean;
    keywords?: string | null;
    month?: string | null;
    page_count?: any | null;
    pdf_url?: string | null;
    published_at?: any | null;
    published_in?: string | null;
    summary?: string | null;
    table_count?: any | null;
    title?: string | null;
    updated_at?: any | null;
    version?: any | null;
    year?: string | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    research_embedding?: {
      __typename?: "research_embeddings";
      chunk: string;
      created_at?: any | null;
      embedding?: any | null;
      embedding_review_id?: any | null;
      id: number;
      is_flagged?: boolean | null;
      research_id: any;
      updated_at: any;
      url?: string | null;
    } | null;
  } | null;
};

export type CreateManyResponseVariables = Exact<{
  objects: Array<ResponsesInsertInput> | ResponsesInsertInput;
  on_conflict?: InputMaybe<ResponsesOnConflict>;
}>;

export type CreateManyResponseResponse = {
  __typename?: "mutation_root";
  insert_responses?: {
    __typename?: "responses_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "responses";
      created_at?: any | null;
      downvotes?: number | null;
      id: any;
      output: string;
      search_id: any;
      upvotes?: number | null;
      search: {
        __typename?: "searches";
        created_at?: any | null;
        embedding?: any | null;
        id: any;
        input: string;
        tokens_used?: any | null;
        user_ids?: Array<any> | null;
      };
    }>;
  } | null;
};

export type CreateOneResponseVariables = Exact<{
  object: ResponsesInsertInput;
  on_conflict?: InputMaybe<ResponsesOnConflict>;
}>;

export type CreateOneResponseResponse = {
  __typename?: "mutation_root";
  insert_responses_one?: {
    __typename?: "responses";
    created_at?: any | null;
    downvotes?: number | null;
    id: any;
    output: string;
    search_id: any;
    upvotes?: number | null;
    search: {
      __typename?: "searches";
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      input: string;
      tokens_used?: any | null;
      user_ids?: Array<any> | null;
    };
  } | null;
};

export type CreateManyRoleHierarchyVariables = Exact<{
  objects: Array<RoleHierarchyInsertInput> | RoleHierarchyInsertInput;
  on_conflict?: InputMaybe<RoleHierarchyOnConflict>;
}>;

export type CreateManyRoleHierarchyResponse = {
  __typename?: "mutation_root";
  insert_role_hierarchy?: {
    __typename?: "role_hierarchy_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "role_hierarchy";
      child_role: any;
      parent_role: any;
    }>;
  } | null;
};

export type CreateOneRoleHierarchyVariables = Exact<{
  object: RoleHierarchyInsertInput;
  on_conflict?: InputMaybe<RoleHierarchyOnConflict>;
}>;

export type CreateOneRoleHierarchyResponse = {
  __typename?: "mutation_root";
  insert_role_hierarchy_one?: {
    __typename?: "role_hierarchy";
    child_role: any;
    parent_role: any;
  } | null;
};

export type CreateManyRolePermissionVariables = Exact<{
  objects: Array<RolePermissionsInsertInput> | RolePermissionsInsertInput;
  on_conflict?: InputMaybe<RolePermissionsOnConflict>;
}>;

export type CreateManyRolePermissionResponse = {
  __typename?: "mutation_root";
  insert_role_permissions?: {
    __typename?: "role_permissions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "role_permissions";
      cached_permissions?: any | null;
      conditions?: any | null;
      id: number;
      inherit_from?: Array<any> | null;
      last_updated?: any | null;
      permissions?: any | null;
      role: any;
      table_name: string;
    }>;
  } | null;
};

export type CreateManyRolePermissionsMaterializedVariables = Exact<{
  objects:
    | Array<RolePermissionsMaterializedInsertInput>
    | RolePermissionsMaterializedInsertInput;
  on_conflict?: InputMaybe<RolePermissionsMaterializedOnConflict>;
}>;

export type CreateManyRolePermissionsMaterializedResponse = {
  __typename?: "mutation_root";
  insert_role_permissions_materialized?: {
    __typename?: "role_permissions_materialized_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "role_permissions_materialized";
      last_updated?: any | null;
      permissions: any;
      role: any;
    }>;
  } | null;
};

export type CreateOneRolePermissionsMaterializedVariables = Exact<{
  object: RolePermissionsMaterializedInsertInput;
  on_conflict?: InputMaybe<RolePermissionsMaterializedOnConflict>;
}>;

export type CreateOneRolePermissionsMaterializedResponse = {
  __typename?: "mutation_root";
  insert_role_permissions_materialized_one?: {
    __typename?: "role_permissions_materialized";
    last_updated?: any | null;
    permissions: any;
    role: any;
  } | null;
};

export type CreateOneRolePermissionVariables = Exact<{
  object: RolePermissionsInsertInput;
  on_conflict?: InputMaybe<RolePermissionsOnConflict>;
}>;

export type CreateOneRolePermissionResponse = {
  __typename?: "mutation_root";
  insert_role_permissions_one?: {
    __typename?: "role_permissions";
    cached_permissions?: any | null;
    conditions?: any | null;
    id: number;
    inherit_from?: Array<any> | null;
    last_updated?: any | null;
    permissions?: any | null;
    role: any;
    table_name: string;
  } | null;
};

export type CreateManyScoringWeightVariables = Exact<{
  objects: Array<ScoringWeightsInsertInput> | ScoringWeightsInsertInput;
  on_conflict?: InputMaybe<ScoringWeightsOnConflict>;
}>;

export type CreateManyScoringWeightResponse = {
  __typename?: "mutation_root";
  insert_scoring_weights?: {
    __typename?: "scoring_weights_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "scoring_weights";
      description?: string | null;
      id: any;
      name: string;
      updated_at?: any | null;
      weight: any;
    }>;
  } | null;
};

export type CreateOneScoringWeightVariables = Exact<{
  object: ScoringWeightsInsertInput;
  on_conflict?: InputMaybe<ScoringWeightsOnConflict>;
}>;

export type CreateOneScoringWeightResponse = {
  __typename?: "mutation_root";
  insert_scoring_weights_one?: {
    __typename?: "scoring_weights";
    description?: string | null;
    id: any;
    name: string;
    updated_at?: any | null;
    weight: any;
  } | null;
};

export type CreateManySearchVariables = Exact<{
  objects: Array<SearchesInsertInput> | SearchesInsertInput;
  on_conflict?: InputMaybe<SearchesOnConflict>;
}>;

export type CreateManySearchResponse = {
  __typename?: "mutation_root";
  insert_searches?: {
    __typename?: "searches_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "searches";
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      input: string;
      tokens_used?: any | null;
      user_ids?: Array<any> | null;
      responses: Array<{
        __typename?: "responses";
        created_at?: any | null;
        downvotes?: number | null;
        id: any;
        output: string;
        search_id: any;
        upvotes?: number | null;
      }>;
    }>;
  } | null;
};

export type CreateOneSearchVariables = Exact<{
  object: SearchesInsertInput;
  on_conflict?: InputMaybe<SearchesOnConflict>;
}>;

export type CreateOneSearchResponse = {
  __typename?: "mutation_root";
  insert_searches_one?: {
    __typename?: "searches";
    created_at?: any | null;
    embedding?: any | null;
    id: any;
    input: string;
    tokens_used?: any | null;
    user_ids?: Array<any> | null;
    responses: Array<{
      __typename?: "responses";
      created_at?: any | null;
      downvotes?: number | null;
      id: any;
      output: string;
      search_id: any;
      upvotes?: number | null;
    }>;
  } | null;
};

export type CreateManySocialMediaVariables = Exact<{
  objects: Array<SocialMediaInsertInput> | SocialMediaInsertInput;
  on_conflict?: InputMaybe<SocialMediaOnConflict>;
}>;

export type CreateManySocialMediaResponse = {
  __typename?: "mutation_root";
  insert_social_media?: {
    __typename?: "social_media_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "social_media";
      created_at?: any | null;
      facebook_url?: string | null;
      id: number;
      instagram_url?: string | null;
      linkedin_url?: string | null;
      twitter_url?: string | null;
      updated_at?: any | null;
      youtube_url?: string | null;
      companies: Array<{
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      }>;
    }>;
  } | null;
};

export type CreateOneSocialMediaVariables = Exact<{
  object: SocialMediaInsertInput;
  on_conflict?: InputMaybe<SocialMediaOnConflict>;
}>;

export type CreateOneSocialMediaResponse = {
  __typename?: "mutation_root";
  insert_social_media_one?: {
    __typename?: "social_media";
    created_at?: any | null;
    facebook_url?: string | null;
    id: number;
    instagram_url?: string | null;
    linkedin_url?: string | null;
    twitter_url?: string | null;
    updated_at?: any | null;
    youtube_url?: string | null;
    companies: Array<{
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    }>;
  } | null;
};

export type CreateManySpiderMetricVariables = Exact<{
  objects: Array<SpiderMetricsInsertInput> | SpiderMetricsInsertInput;
  on_conflict?: InputMaybe<SpiderMetricsOnConflict>;
}>;

export type CreateManySpiderMetricResponse = {
  __typename?: "mutation_root";
  insert_spider_metrics?: {
    __typename?: "spider_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "spider_metrics";
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
      metric_definition?: {
        __typename?: "metric_definitions";
        category?: string | null;
        description?: string | null;
        id: number;
        is_dimensional?: boolean | null;
        name: string;
        type: string;
        unit?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneSpiderMetricVariables = Exact<{
  object: SpiderMetricsInsertInput;
  on_conflict?: InputMaybe<SpiderMetricsOnConflict>;
}>;

export type CreateOneSpiderMetricResponse = {
  __typename?: "mutation_root";
  insert_spider_metrics_one?: {
    __typename?: "spider_metrics";
    crawl_id: any;
    id: any;
    metric_id?: number | null;
    timestamp: any;
    value: any;
    metric_definition?: {
      __typename?: "metric_definitions";
      category?: string | null;
      description?: string | null;
      id: number;
      is_dimensional?: boolean | null;
      name: string;
      type: string;
      unit?: string | null;
    } | null;
  } | null;
};

export type CreateManyStrapiMigrationVariables = Exact<{
  objects: Array<StrapiMigrationsInsertInput> | StrapiMigrationsInsertInput;
  on_conflict?: InputMaybe<StrapiMigrationsOnConflict>;
}>;

export type CreateManyStrapiMigrationResponse = {
  __typename?: "mutation_root";
  insert_strapi_migrations?: {
    __typename?: "strapi_migrations_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "strapi_migrations";
      id: number;
      name?: string | null;
      time?: any | null;
    }>;
  } | null;
};

export type CreateManyStrapiMigrationsInternalVariables = Exact<{
  objects:
    | Array<StrapiMigrationsInternalInsertInput>
    | StrapiMigrationsInternalInsertInput;
  on_conflict?: InputMaybe<StrapiMigrationsInternalOnConflict>;
}>;

export type CreateManyStrapiMigrationsInternalResponse = {
  __typename?: "mutation_root";
  insert_strapi_migrations_internal?: {
    __typename?: "strapi_migrations_internal_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "strapi_migrations_internal";
      id: number;
      name?: string | null;
      time?: any | null;
    }>;
  } | null;
};

export type CreateOneStrapiMigrationsInternalVariables = Exact<{
  object: StrapiMigrationsInternalInsertInput;
  on_conflict?: InputMaybe<StrapiMigrationsInternalOnConflict>;
}>;

export type CreateOneStrapiMigrationsInternalResponse = {
  __typename?: "mutation_root";
  insert_strapi_migrations_internal_one?: {
    __typename?: "strapi_migrations_internal";
    id: number;
    name?: string | null;
    time?: any | null;
  } | null;
};

export type CreateOneStrapiMigrationVariables = Exact<{
  object: StrapiMigrationsInsertInput;
  on_conflict?: InputMaybe<StrapiMigrationsOnConflict>;
}>;

export type CreateOneStrapiMigrationResponse = {
  __typename?: "mutation_root";
  insert_strapi_migrations_one?: {
    __typename?: "strapi_migrations";
    id: number;
    name?: string | null;
    time?: any | null;
  } | null;
};

export type CreateManyTableMaintenanceLogVariables = Exact<{
  objects:
    | Array<TableMaintenanceLogInsertInput>
    | TableMaintenanceLogInsertInput;
  on_conflict?: InputMaybe<TableMaintenanceLogOnConflict>;
}>;

export type CreateManyTableMaintenanceLogResponse = {
  __typename?: "mutation_root";
  insert_table_maintenance_log?: {
    __typename?: "table_maintenance_log_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_maintenance_log";
      detail?: string | null;
      id: number;
      logged_at?: any | null;
      operation?: string | null;
    }>;
  } | null;
};

export type CreateOneTableMaintenanceLogVariables = Exact<{
  object: TableMaintenanceLogInsertInput;
  on_conflict?: InputMaybe<TableMaintenanceLogOnConflict>;
}>;

export type CreateOneTableMaintenanceLogResponse = {
  __typename?: "mutation_root";
  insert_table_maintenance_log_one?: {
    __typename?: "table_maintenance_log";
    detail?: string | null;
    id: number;
    logged_at?: any | null;
    operation?: string | null;
  } | null;
};

export type CreateManyTableQueryPerformanceVariables = Exact<{
  objects:
    | Array<TableQueryPerformanceInsertInput>
    | TableQueryPerformanceInsertInput;
  on_conflict?: InputMaybe<TableQueryPerformanceOnConflict>;
}>;

export type CreateManyTableQueryPerformanceResponse = {
  __typename?: "mutation_root";
  insert_table_query_performance?: {
    __typename?: "table_query_performance_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_query_performance";
      avg_duration?: any | null;
      capture_time?: any | null;
      execution_count?: any | null;
      query?: string | null;
    }>;
  } | null;
};

export type CreateOneTableQueryPerformanceVariables = Exact<{
  object: TableQueryPerformanceInsertInput;
  on_conflict?: InputMaybe<TableQueryPerformanceOnConflict>;
}>;

export type CreateOneTableQueryPerformanceResponse = {
  __typename?: "mutation_root";
  insert_table_query_performance_one?: {
    __typename?: "table_query_performance";
    avg_duration?: any | null;
    capture_time?: any | null;
    execution_count?: any | null;
    query?: string | null;
  } | null;
};

export type CreateManyTableSequenceUsageVariables = Exact<{
  objects: Array<TableSequenceUsageInsertInput> | TableSequenceUsageInsertInput;
  on_conflict?: InputMaybe<TableSequenceUsageOnConflict>;
}>;

export type CreateManyTableSequenceUsageResponse = {
  __typename?: "mutation_root";
  insert_table_sequence_usage?: {
    __typename?: "table_sequence_usage_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_sequence_usage";
      capture_time?: any | null;
      current_value?: any | null;
      max_value?: any | null;
      sequence_name?: string | null;
    }>;
  } | null;
};

export type CreateOneTableSequenceUsageVariables = Exact<{
  object: TableSequenceUsageInsertInput;
  on_conflict?: InputMaybe<TableSequenceUsageOnConflict>;
}>;

export type CreateOneTableSequenceUsageResponse = {
  __typename?: "mutation_root";
  insert_table_sequence_usage_one?: {
    __typename?: "table_sequence_usage";
    capture_time?: any | null;
    current_value?: any | null;
    max_value?: any | null;
    sequence_name?: string | null;
  } | null;
};

export type CreateManyTableStatisticVariables = Exact<{
  objects: Array<TableStatisticsInsertInput> | TableStatisticsInsertInput;
  on_conflict?: InputMaybe<TableStatisticsOnConflict>;
}>;

export type CreateManyTableStatisticResponse = {
  __typename?: "mutation_root";
  insert_table_statistics?: {
    __typename?: "table_statistics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_statistics";
      buffer_cache_hit_ratio?: any | null;
      capture_time: any;
      dead_tuples?: any | null;
      estimated_bloat_ratio?: any | null;
      index_scan_count?: any | null;
      index_size?: any | null;
      index_usage?: any | null;
      last_analyze?: any | null;
      last_vacuum?: any | null;
      live_tuples?: any | null;
      row_count?: any | null;
      seq_scan_count?: any | null;
      table_name: string;
      table_size?: any | null;
    }>;
  } | null;
};

export type CreateOneTableStatisticVariables = Exact<{
  object: TableStatisticsInsertInput;
  on_conflict?: InputMaybe<TableStatisticsOnConflict>;
}>;

export type CreateOneTableStatisticResponse = {
  __typename?: "mutation_root";
  insert_table_statistics_one?: {
    __typename?: "table_statistics";
    buffer_cache_hit_ratio?: any | null;
    capture_time: any;
    dead_tuples?: any | null;
    estimated_bloat_ratio?: any | null;
    index_scan_count?: any | null;
    index_size?: any | null;
    index_usage?: any | null;
    last_analyze?: any | null;
    last_vacuum?: any | null;
    live_tuples?: any | null;
    row_count?: any | null;
    seq_scan_count?: any | null;
    table_name: string;
    table_size?: any | null;
  } | null;
};

export type CreateManyTagVariables = Exact<{
  objects: Array<TagsInsertInput> | TagsInsertInput;
  on_conflict?: InputMaybe<TagsOnConflict>;
}>;

export type CreateManyTagResponse = {
  __typename?: "mutation_root";
  insert_tags?: {
    __typename?: "tags_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "tags";
      body?: string | null;
      created_at?: any | null;
      document_id?: string | null;
      id: number;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
      content_tags: Array<{
        __typename?: "content_tags";
        content_id: any;
        tag_id: number;
      }>;
      news_tags: Array<{
        __typename?: "news_tags";
        id: number;
        news_id?: any | null;
        tag_id: number;
      }>;
    }>;
  } | null;
};

export type CreateOneTagVariables = Exact<{
  object: TagsInsertInput;
  on_conflict?: InputMaybe<TagsOnConflict>;
}>;

export type CreateOneTagResponse = {
  __typename?: "mutation_root";
  insert_tags_one?: {
    __typename?: "tags";
    body?: string | null;
    created_at?: any | null;
    document_id?: string | null;
    id: number;
    locale?: string | null;
    name: string;
    published_at?: string | null;
    updated_at?: any | null;
    content_tags: Array<{
      __typename?: "content_tags";
      content_id: any;
      tag_id: number;
    }>;
    news_tags: Array<{
      __typename?: "news_tags";
      id: number;
      news_id?: any | null;
      tag_id: number;
    }>;
  } | null;
};

export type CreateManyUserMetricVariables = Exact<{
  objects: Array<UserMetricsInsertInput> | UserMetricsInsertInput;
  on_conflict?: InputMaybe<UserMetricsOnConflict>;
}>;

export type CreateManyUserMetricResponse = {
  __typename?: "mutation_root";
  insert_user_metrics?: {
    __typename?: "user_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "user_metrics";
      achievements?: any | null;
      best_streak?: number | null;
      created_at?: any | null;
      current_level?: number | null;
      current_streak?: number | null;
      current_xp?: number | null;
      downvote_count?: number | null;
      id: any;
      interaction_stats?: any | null;
      last_vote_date?: any | null;
      multipliers?: any | null;
      points?: number | null;
      points_breakdown?: any | null;
      titles?: any | null;
      today_vote_count?: number | null;
      total_reading_time?: number | null;
      total_votes?: number | null;
      updated_at?: any | null;
      upvote_count?: number | null;
      user_id: any;
      vote_accuracy?: any | null;
      xp_to_next_level?: number | null;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneUserMetricVariables = Exact<{
  object: UserMetricsInsertInput;
  on_conflict?: InputMaybe<UserMetricsOnConflict>;
}>;

export type CreateOneUserMetricResponse = {
  __typename?: "mutation_root";
  insert_user_metrics_one?: {
    __typename?: "user_metrics";
    achievements?: any | null;
    best_streak?: number | null;
    created_at?: any | null;
    current_level?: number | null;
    current_streak?: number | null;
    current_xp?: number | null;
    downvote_count?: number | null;
    id: any;
    interaction_stats?: any | null;
    last_vote_date?: any | null;
    multipliers?: any | null;
    points?: number | null;
    points_breakdown?: any | null;
    titles?: any | null;
    today_vote_count?: number | null;
    total_reading_time?: number | null;
    total_votes?: number | null;
    updated_at?: any | null;
    upvote_count?: number | null;
    user_id: any;
    vote_accuracy?: any | null;
    xp_to_next_level?: number | null;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type CreateManyUserProfileVariables = Exact<{
  objects: Array<UserProfilesInsertInput> | UserProfilesInsertInput;
  on_conflict?: InputMaybe<UserProfilesOnConflict>;
}>;

export type CreateManyUserProfileResponse = {
  __typename?: "mutation_root";
  insert_user_profiles?: {
    __typename?: "user_profiles_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      comments: Array<{
        __typename?: "comments";
        content: string;
        content_id: any;
        content_type: any;
        created_at?: any | null;
        id: any;
        parent_comment_id?: any | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      company_employees: Array<{
        __typename?: "company_employees";
        access_level: any;
        company_id?: any | null;
        created_at?: any | null;
        end_date?: any | null;
        id: any;
        job_description?: string | null;
        role: string;
        start_date?: any | null;
        status?: boolean | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      contacts: Array<{
        __typename?: "contacts";
        company_id?: any | null;
        contact_type?: any | null;
        created_at?: any | null;
        email?: string | null;
        id: number;
        is_primary?: boolean | null;
        phone?: string | null;
        privacy_level?: any | null;
        title?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      content_source_visits: Array<{
        __typename?: "content_source_visits";
        content_id: any;
        created_at?: any | null;
        id: any;
        user_id?: any | null;
      }>;
      customer_payments: Array<{
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      }>;
      customer_subscriptions: Array<{
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      feedbacks: Array<{
        __typename?: "feedbacks";
        created_at: any;
        device_info?: string | null;
        feedback_status?: any | null;
        feedback_type?: any | null;
        id: number;
        message: string;
        page_identifier: string;
        rating?: number | null;
        resolution_comment?: string | null;
        updated_at: any;
        user_id?: any | null;
      }>;
      feeds: Array<{
        __typename?: "feeds";
        created_at: any;
        id: any;
        name?: string | null;
        user_id?: any | null;
      }>;
      follows: Array<{
        __typename?: "follows";
        created_at?: any | null;
        followed_entity: any;
        followed_id: any;
        id: any;
        user_id: any;
      }>;
      user_metric?: {
        __typename?: "user_metrics";
        achievements?: any | null;
        best_streak?: number | null;
        created_at?: any | null;
        current_level?: number | null;
        current_streak?: number | null;
        current_xp?: number | null;
        downvote_count?: number | null;
        id: any;
        interaction_stats?: any | null;
        last_vote_date?: any | null;
        multipliers?: any | null;
        points?: number | null;
        points_breakdown?: any | null;
        titles?: any | null;
        today_vote_count?: number | null;
        total_reading_time?: number | null;
        total_votes?: number | null;
        updated_at?: any | null;
        upvote_count?: number | null;
        user_id: any;
        vote_accuracy?: any | null;
        xp_to_next_level?: number | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneUserProfileVariables = Exact<{
  object: UserProfilesInsertInput;
  on_conflict?: InputMaybe<UserProfilesOnConflict>;
}>;

export type CreateOneUserProfileResponse = {
  __typename?: "mutation_root";
  insert_user_profiles_one?: {
    __typename?: "user_profiles";
    avatar?: string | null;
    created_at?: any | null;
    dob?: any | null;
    email: string;
    followed_count?: number | null;
    followers_count?: number | null;
    gender_id?: any | null;
    given_name?: string | null;
    id: any;
    introduction?: string | null;
    is_active?: boolean | null;
    last_seen?: any | null;
    plan?: any | null;
    role: any;
    surname?: string | null;
    updated_at?: any | null;
    username?: string | null;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    comments: Array<{
      __typename?: "comments";
      content: string;
      content_id: any;
      content_type: any;
      created_at?: any | null;
      id: any;
      parent_comment_id?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    company_employees: Array<{
      __typename?: "company_employees";
      access_level: any;
      company_id?: any | null;
      created_at?: any | null;
      end_date?: any | null;
      id: any;
      job_description?: string | null;
      role: string;
      start_date?: any | null;
      status?: boolean | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    contacts: Array<{
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    content_source_visits: Array<{
      __typename?: "content_source_visits";
      content_id: any;
      created_at?: any | null;
      id: any;
      user_id?: any | null;
    }>;
    customer_payments: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
    customer_subscriptions: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    feedbacks: Array<{
      __typename?: "feedbacks";
      created_at: any;
      device_info?: string | null;
      feedback_status?: any | null;
      feedback_type?: any | null;
      id: number;
      message: string;
      page_identifier: string;
      rating?: number | null;
      resolution_comment?: string | null;
      updated_at: any;
      user_id?: any | null;
    }>;
    feeds: Array<{
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    }>;
    follows: Array<{
      __typename?: "follows";
      created_at?: any | null;
      followed_entity: any;
      followed_id: any;
      id: any;
      user_id: any;
    }>;
    user_metric?: {
      __typename?: "user_metrics";
      achievements?: any | null;
      best_streak?: number | null;
      created_at?: any | null;
      current_level?: number | null;
      current_streak?: number | null;
      current_xp?: number | null;
      downvote_count?: number | null;
      id: any;
      interaction_stats?: any | null;
      last_vote_date?: any | null;
      multipliers?: any | null;
      points?: number | null;
      points_breakdown?: any | null;
      titles?: any | null;
      today_vote_count?: number | null;
      total_reading_time?: number | null;
      total_votes?: number | null;
      updated_at?: any | null;
      upvote_count?: number | null;
      user_id: any;
      vote_accuracy?: any | null;
      xp_to_next_level?: number | null;
    } | null;
  } | null;
};

export type CreateManyVoteVariables = Exact<{
  objects: Array<VotesInsertInput> | VotesInsertInput;
  on_conflict?: InputMaybe<VotesOnConflict>;
}>;

export type CreateManyVoteResponse = {
  __typename?: "mutation_root";
  insert_votes?: {
    __typename?: "votes_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "votes";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      id: any;
      user_id: any;
      vote_type: any;
    }>;
  } | null;
};

export type CreateOneVoteVariables = Exact<{
  object: VotesInsertInput;
  on_conflict?: InputMaybe<VotesOnConflict>;
}>;

export type CreateOneVoteResponse = {
  __typename?: "mutation_root";
  insert_votes_one?: {
    __typename?: "votes";
    content_id: any;
    content_type: string;
    created_at?: any | null;
    id: any;
    user_id: any;
    vote_type: any;
  } | null;
};

export type CreateManyWorkflowVariables = Exact<{
  objects: Array<WorkflowsInsertInput> | WorkflowsInsertInput;
  on_conflict?: InputMaybe<WorkflowsOnConflict>;
}>;

export type CreateManyWorkflowResponse = {
  __typename?: "mutation_root";
  insert_workflows?: {
    __typename?: "workflows_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "workflows";
      completed_at?: any | null;
      created_at?: any | null;
      id: any;
      metadata?: any | null;
      name: string;
      started_at?: any | null;
      status: any;
      updated_at?: any | null;
    }>;
  } | null;
};

export type CreateOneWorkflowVariables = Exact<{
  object: WorkflowsInsertInput;
  on_conflict?: InputMaybe<WorkflowsOnConflict>;
}>;

export type CreateOneWorkflowResponse = {
  __typename?: "mutation_root";
  insert_workflows_one?: {
    __typename?: "workflows";
    completed_at?: any | null;
    created_at?: any | null;
    id: any;
    metadata?: any | null;
    name: string;
    started_at?: any | null;
    status: any;
    updated_at?: any | null;
  } | null;
};

export type MatchResearchVariables = Exact<{
  args: MatchResearchArgs;
  distinct_on?: InputMaybe<
    Array<ResearchEmbeddingsSelectColumn> | ResearchEmbeddingsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    Array<ResearchEmbeddingsOrderBy> | ResearchEmbeddingsOrderBy
  >;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
}>;

export type MatchResearchResponse = {
  __typename?: "mutation_root";
  match_research: Array<{
    __typename?: "research_embeddings";
    chunk: string;
    created_at?: any | null;
    embedding?: any | null;
    embedding_review_id?: any | null;
    id: number;
    is_flagged?: boolean | null;
    research_id: any;
    updated_at: any;
    url?: string | null;
    embedding_review?: {
      __typename?: "embedding_reviews";
      agent_review?: boolean | null;
      created_at: any;
      human_review?: boolean | null;
      id: any;
      notes?: string | null;
      updated_at?: any | null;
    } | null;
    research: {
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
    };
  }>;
};

export type UpdateManyAdDailyMetricVariables = Exact<{
  _inc?: InputMaybe<AdDailyMetricsIncInput>;
  _set?: InputMaybe<AdDailyMetricsSetInput>;
  where: AdDailyMetricsBoolExp;
}>;

export type UpdateManyAdDailyMetricResponse = {
  __typename?: "mutation_root";
  update_ad_daily_metrics?: {
    __typename?: "ad_daily_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ad_daily_metrics";
      clicks?: number | null;
      created_at?: any | null;
      date: any;
      id: any;
      updated_at?: any | null;
      variant_id?: any | null;
      views?: number | null;
      ad_variant?: {
        __typename?: "ad_variants";
        active?: boolean | null;
        ad_id: any;
        content: any;
        created_at?: any | null;
        id: any;
        is_control?: boolean | null;
        performance_metrics?: any | null;
        updated_at?: any | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneAdDailyMetricVariables = Exact<{
  _inc?: InputMaybe<AdDailyMetricsIncInput>;
  _set?: InputMaybe<AdDailyMetricsSetInput>;
  pk_columns: AdDailyMetricsPkColumnsInput;
}>;

export type UpdateOneAdDailyMetricResponse = {
  __typename?: "mutation_root";
  update_ad_daily_metrics_by_pk?: {
    __typename?: "ad_daily_metrics";
    clicks?: number | null;
    created_at?: any | null;
    date: any;
    id: any;
    updated_at?: any | null;
    variant_id?: any | null;
    views?: number | null;
    ad_variant?: {
      __typename?: "ad_variants";
      active?: boolean | null;
      ad_id: any;
      content: any;
      created_at?: any | null;
      id: any;
      is_control?: boolean | null;
      performance_metrics?: any | null;
      updated_at?: any | null;
    } | null;
  } | null;
};

export type UpdateManyAdDailyMetricsManyVariables = Exact<{
  updates: Array<AdDailyMetricsUpdates> | AdDailyMetricsUpdates;
}>;

export type UpdateManyAdDailyMetricsManyResponse = {
  __typename?: "mutation_root";
  update_ad_daily_metrics_many?: Array<{
    __typename?: "ad_daily_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ad_daily_metrics";
      clicks?: number | null;
      created_at?: any | null;
      date: any;
      id: any;
      updated_at?: any | null;
      variant_id?: any | null;
      views?: number | null;
      ad_variant?: {
        __typename?: "ad_variants";
        active?: boolean | null;
        ad_id: any;
        content: any;
        created_at?: any | null;
        id: any;
        is_control?: boolean | null;
        performance_metrics?: any | null;
        updated_at?: any | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyAdPackageVariables = Exact<{
  _inc?: InputMaybe<AdPackagesIncInput>;
  _set?: InputMaybe<AdPackagesSetInput>;
  where: AdPackagesBoolExp;
}>;

export type UpdateManyAdPackageResponse = {
  __typename?: "mutation_root";
  update_ad_packages?: {
    __typename?: "ad_packages_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ad_packages";
      active?: boolean | null;
      avg_roi?: any | null;
      created_at?: any | null;
      description: string;
      expected_ctr?: any | null;
      features: Array<string>;
      id: any;
      name: string;
      position: string;
      price: any;
      updated_at?: any | null;
      view_frequency?: any | null;
      ads: Array<{
        __typename?: "ads";
        active?: boolean | null;
        company_id?: any | null;
        created_at?: any | null;
        end_date: any;
        id: any;
        package_id?: any | null;
        start_date: any;
        updated_at?: any | null;
      }>;
    }>;
  } | null;
};

export type UpdateOneAdPackageVariables = Exact<{
  _inc?: InputMaybe<AdPackagesIncInput>;
  _set?: InputMaybe<AdPackagesSetInput>;
  pk_columns: AdPackagesPkColumnsInput;
}>;

export type UpdateOneAdPackageResponse = {
  __typename?: "mutation_root";
  update_ad_packages_by_pk?: {
    __typename?: "ad_packages";
    active?: boolean | null;
    avg_roi?: any | null;
    created_at?: any | null;
    description: string;
    expected_ctr?: any | null;
    features: Array<string>;
    id: any;
    name: string;
    position: string;
    price: any;
    updated_at?: any | null;
    view_frequency?: any | null;
    ads: Array<{
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    }>;
  } | null;
};

export type UpdateManyAdPackagesManyVariables = Exact<{
  updates: Array<AdPackagesUpdates> | AdPackagesUpdates;
}>;

export type UpdateManyAdPackagesManyResponse = {
  __typename?: "mutation_root";
  update_ad_packages_many?: Array<{
    __typename?: "ad_packages_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ad_packages";
      active?: boolean | null;
      avg_roi?: any | null;
      created_at?: any | null;
      description: string;
      expected_ctr?: any | null;
      features: Array<string>;
      id: any;
      name: string;
      position: string;
      price: any;
      updated_at?: any | null;
      view_frequency?: any | null;
      ads: Array<{
        __typename?: "ads";
        active?: boolean | null;
        company_id?: any | null;
        created_at?: any | null;
        end_date: any;
        id: any;
        package_id?: any | null;
        start_date: any;
        updated_at?: any | null;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyAdVariantVariables = Exact<{
  _append?: InputMaybe<AdVariantsAppendInput>;
  _delete_at_path?: InputMaybe<AdVariantsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<AdVariantsDeleteElemInput>;
  _delete_key?: InputMaybe<AdVariantsDeleteKeyInput>;
  _prepend?: InputMaybe<AdVariantsPrependInput>;
  _set?: InputMaybe<AdVariantsSetInput>;
  where: AdVariantsBoolExp;
}>;

export type UpdateManyAdVariantResponse = {
  __typename?: "mutation_root";
  update_ad_variants?: {
    __typename?: "ad_variants_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ad_variants";
      active?: boolean | null;
      ad_id: any;
      content: any;
      created_at?: any | null;
      id: any;
      is_control?: boolean | null;
      performance_metrics?: any | null;
      updated_at?: any | null;
      ad: {
        __typename?: "ads";
        active?: boolean | null;
        company_id?: any | null;
        created_at?: any | null;
        end_date: any;
        id: any;
        package_id?: any | null;
        start_date: any;
        updated_at?: any | null;
      };
      ad_daily_metrics: Array<{
        __typename?: "ad_daily_metrics";
        clicks?: number | null;
        created_at?: any | null;
        date: any;
        id: any;
        updated_at?: any | null;
        variant_id?: any | null;
        views?: number | null;
      }>;
    }>;
  } | null;
};

export type UpdateOneAdVariantVariables = Exact<{
  _append?: InputMaybe<AdVariantsAppendInput>;
  _delete_at_path?: InputMaybe<AdVariantsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<AdVariantsDeleteElemInput>;
  _delete_key?: InputMaybe<AdVariantsDeleteKeyInput>;
  _prepend?: InputMaybe<AdVariantsPrependInput>;
  _set?: InputMaybe<AdVariantsSetInput>;
  pk_columns: AdVariantsPkColumnsInput;
}>;

export type UpdateOneAdVariantResponse = {
  __typename?: "mutation_root";
  update_ad_variants_by_pk?: {
    __typename?: "ad_variants";
    active?: boolean | null;
    ad_id: any;
    content: any;
    created_at?: any | null;
    id: any;
    is_control?: boolean | null;
    performance_metrics?: any | null;
    updated_at?: any | null;
    ad: {
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    };
    ad_daily_metrics: Array<{
      __typename?: "ad_daily_metrics";
      clicks?: number | null;
      created_at?: any | null;
      date: any;
      id: any;
      updated_at?: any | null;
      variant_id?: any | null;
      views?: number | null;
    }>;
  } | null;
};

export type UpdateManyAdVariantsManyVariables = Exact<{
  updates: Array<AdVariantsUpdates> | AdVariantsUpdates;
}>;

export type UpdateManyAdVariantsManyResponse = {
  __typename?: "mutation_root";
  update_ad_variants_many?: Array<{
    __typename?: "ad_variants_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ad_variants";
      active?: boolean | null;
      ad_id: any;
      content: any;
      created_at?: any | null;
      id: any;
      is_control?: boolean | null;
      performance_metrics?: any | null;
      updated_at?: any | null;
      ad: {
        __typename?: "ads";
        active?: boolean | null;
        company_id?: any | null;
        created_at?: any | null;
        end_date: any;
        id: any;
        package_id?: any | null;
        start_date: any;
        updated_at?: any | null;
      };
      ad_daily_metrics: Array<{
        __typename?: "ad_daily_metrics";
        clicks?: number | null;
        created_at?: any | null;
        date: any;
        id: any;
        updated_at?: any | null;
        variant_id?: any | null;
        views?: number | null;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyAddressVariables = Exact<{
  _inc?: InputMaybe<AddressesIncInput>;
  _set?: InputMaybe<AddressesSetInput>;
  where: AddressesBoolExp;
}>;

export type UpdateManyAddressResponse = {
  __typename?: "mutation_root";
  update_addresses?: {
    __typename?: "addresses_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
      city: {
        __typename?: "cities";
        country_id: number;
        id: number;
        name: string;
        state?: string | null;
      };
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      country: {
        __typename?: "countries";
        code: string;
        code_3?: string | null;
        id: number;
        name: string;
      };
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneAddressVariables = Exact<{
  _inc?: InputMaybe<AddressesIncInput>;
  _set?: InputMaybe<AddressesSetInput>;
  pk_columns: AddressesPkColumnsInput;
}>;

export type UpdateOneAddressResponse = {
  __typename?: "mutation_root";
  update_addresses_by_pk?: {
    __typename?: "addresses";
    address_type?: any | null;
    city_id: number;
    company_id?: any | null;
    country_id: number;
    created_at?: any | null;
    id: number;
    is_primary?: boolean | null;
    name?: string | null;
    street1: string;
    street2?: string | null;
    updated_at?: any | null;
    user_id?: any | null;
    city: {
      __typename?: "cities";
      country_id: number;
      id: number;
      name: string;
      state?: string | null;
    };
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    country: {
      __typename?: "countries";
      code: string;
      code_3?: string | null;
      id: number;
      name: string;
    };
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type UpdateManyAddressesManyVariables = Exact<{
  updates: Array<AddressesUpdates> | AddressesUpdates;
}>;

export type UpdateManyAddressesManyResponse = {
  __typename?: "mutation_root";
  update_addresses_many?: Array<{
    __typename?: "addresses_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
      city: {
        __typename?: "cities";
        country_id: number;
        id: number;
        name: string;
        state?: string | null;
      };
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      country: {
        __typename?: "countries";
        code: string;
        code_3?: string | null;
        id: number;
        name: string;
      };
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyAdVariables = Exact<{
  _set?: InputMaybe<AdsSetInput>;
  where: AdsBoolExp;
}>;

export type UpdateManyAdResponse = {
  __typename?: "mutation_root";
  update_ads?: {
    __typename?: "ads_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
      ad_package?: {
        __typename?: "ad_packages";
        active?: boolean | null;
        avg_roi?: any | null;
        created_at?: any | null;
        description: string;
        expected_ctr?: any | null;
        features: Array<string>;
        id: any;
        name: string;
        position: string;
        price: any;
        updated_at?: any | null;
        view_frequency?: any | null;
      } | null;
      ad_variants: Array<{
        __typename?: "ad_variants";
        active?: boolean | null;
        ad_id: any;
        content: any;
        created_at?: any | null;
        id: any;
        is_control?: boolean | null;
        performance_metrics?: any | null;
        updated_at?: any | null;
      }>;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null;
};

export type UpdateOneAdVariables = Exact<{
  _set?: InputMaybe<AdsSetInput>;
  pk_columns: AdsPkColumnsInput;
}>;

export type UpdateOneAdResponse = {
  __typename?: "mutation_root";
  update_ads_by_pk?: {
    __typename?: "ads";
    active?: boolean | null;
    company_id?: any | null;
    created_at?: any | null;
    end_date: any;
    id: any;
    package_id?: any | null;
    start_date: any;
    updated_at?: any | null;
    ad_package?: {
      __typename?: "ad_packages";
      active?: boolean | null;
      avg_roi?: any | null;
      created_at?: any | null;
      description: string;
      expected_ctr?: any | null;
      features: Array<string>;
      id: any;
      name: string;
      position: string;
      price: any;
      updated_at?: any | null;
      view_frequency?: any | null;
    } | null;
    ad_variants: Array<{
      __typename?: "ad_variants";
      active?: boolean | null;
      ad_id: any;
      content: any;
      created_at?: any | null;
      id: any;
      is_control?: boolean | null;
      performance_metrics?: any | null;
      updated_at?: any | null;
    }>;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type UpdateManyAdsManyVariables = Exact<{
  updates: Array<AdsUpdates> | AdsUpdates;
}>;

export type UpdateManyAdsManyResponse = {
  __typename?: "mutation_root";
  update_ads_many?: Array<{
    __typename?: "ads_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
      ad_package?: {
        __typename?: "ad_packages";
        active?: boolean | null;
        avg_roi?: any | null;
        created_at?: any | null;
        description: string;
        expected_ctr?: any | null;
        features: Array<string>;
        id: any;
        name: string;
        position: string;
        price: any;
        updated_at?: any | null;
        view_frequency?: any | null;
      } | null;
      ad_variants: Array<{
        __typename?: "ad_variants";
        active?: boolean | null;
        ad_id: any;
        content: any;
        created_at?: any | null;
        id: any;
        is_control?: boolean | null;
        performance_metrics?: any | null;
        updated_at?: any | null;
      }>;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyBlacklistedDomainVariables = Exact<{
  _set?: InputMaybe<BlacklistedDomainsSetInput>;
  where: BlacklistedDomainsBoolExp;
}>;

export type UpdateManyBlacklistedDomainResponse = {
  __typename?: "mutation_root";
  update_blacklisted_domains?: {
    __typename?: "blacklisted_domains_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "blacklisted_domains";
      created_at: any;
      id: any;
      reason?: string | null;
      url: string;
    }>;
  } | null;
};

export type UpdateOneBlacklistedDomainVariables = Exact<{
  _set?: InputMaybe<BlacklistedDomainsSetInput>;
  pk_columns: BlacklistedDomainsPkColumnsInput;
}>;

export type UpdateOneBlacklistedDomainResponse = {
  __typename?: "mutation_root";
  update_blacklisted_domains_by_pk?: {
    __typename?: "blacklisted_domains";
    created_at: any;
    id: any;
    reason?: string | null;
    url: string;
  } | null;
};

export type UpdateManyBlacklistedDomainsManyVariables = Exact<{
  updates: Array<BlacklistedDomainsUpdates> | BlacklistedDomainsUpdates;
}>;

export type UpdateManyBlacklistedDomainsManyResponse = {
  __typename?: "mutation_root";
  update_blacklisted_domains_many?: Array<{
    __typename?: "blacklisted_domains_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "blacklisted_domains";
      created_at: any;
      id: any;
      reason?: string | null;
      url: string;
    }>;
  } | null> | null;
};

export type UpdateManyBlacklistedUrlVariables = Exact<{
  _inc?: InputMaybe<BlacklistedUrlsIncInput>;
  _set?: InputMaybe<BlacklistedUrlsSetInput>;
  where: BlacklistedUrlsBoolExp;
}>;

export type UpdateManyBlacklistedUrlResponse = {
  __typename?: "mutation_root";
  update_blacklisted_urls?: {
    __typename?: "blacklisted_urls_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "blacklisted_urls";
      company_id?: any | null;
      created_at?: any | null;
      id: number;
      reason?: string | null;
      url: string;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null;
};

export type UpdateOneBlacklistedUrlVariables = Exact<{
  _inc?: InputMaybe<BlacklistedUrlsIncInput>;
  _set?: InputMaybe<BlacklistedUrlsSetInput>;
  pk_columns: BlacklistedUrlsPkColumnsInput;
}>;

export type UpdateOneBlacklistedUrlResponse = {
  __typename?: "mutation_root";
  update_blacklisted_urls_by_pk?: {
    __typename?: "blacklisted_urls";
    company_id?: any | null;
    created_at?: any | null;
    id: number;
    reason?: string | null;
    url: string;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type UpdateManyBlacklistedUrlsManyVariables = Exact<{
  updates: Array<BlacklistedUrlsUpdates> | BlacklistedUrlsUpdates;
}>;

export type UpdateManyBlacklistedUrlsManyResponse = {
  __typename?: "mutation_root";
  update_blacklisted_urls_many?: Array<{
    __typename?: "blacklisted_urls_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "blacklisted_urls";
      company_id?: any | null;
      created_at?: any | null;
      id: number;
      reason?: string | null;
      url: string;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyBlockedIpVariables = Exact<{
  _inc?: InputMaybe<BlockedIpsIncInput>;
  _set?: InputMaybe<BlockedIpsSetInput>;
  where: BlockedIpsBoolExp;
}>;

export type UpdateManyBlockedIpResponse = {
  __typename?: "mutation_root";
  update_blocked_ips?: {
    __typename?: "blocked_ips_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "blocked_ips";
      blocked_at?: any | null;
      blocked_until: any;
      created_at?: any | null;
      failed_attempts?: number | null;
      id: any;
      ip_address: any;
      reason?: string | null;
      updated_at?: any | null;
    }>;
  } | null;
};

export type UpdateOneBlockedIpVariables = Exact<{
  _inc?: InputMaybe<BlockedIpsIncInput>;
  _set?: InputMaybe<BlockedIpsSetInput>;
  pk_columns: BlockedIpsPkColumnsInput;
}>;

export type UpdateOneBlockedIpResponse = {
  __typename?: "mutation_root";
  update_blocked_ips_by_pk?: {
    __typename?: "blocked_ips";
    blocked_at?: any | null;
    blocked_until: any;
    created_at?: any | null;
    failed_attempts?: number | null;
    id: any;
    ip_address: any;
    reason?: string | null;
    updated_at?: any | null;
  } | null;
};

export type UpdateManyBlockedIpsManyVariables = Exact<{
  updates: Array<BlockedIpsUpdates> | BlockedIpsUpdates;
}>;

export type UpdateManyBlockedIpsManyResponse = {
  __typename?: "mutation_root";
  update_blocked_ips_many?: Array<{
    __typename?: "blocked_ips_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "blocked_ips";
      blocked_at?: any | null;
      blocked_until: any;
      created_at?: any | null;
      failed_attempts?: number | null;
      id: any;
      ip_address: any;
      reason?: string | null;
      updated_at?: any | null;
    }>;
  } | null> | null;
};

export type UpdateManyBookmarkFolderVariables = Exact<{
  _inc?: InputMaybe<BookmarkFoldersIncInput>;
  _set?: InputMaybe<BookmarkFoldersSetInput>;
  where: BookmarkFoldersBoolExp;
}>;

export type UpdateManyBookmarkFolderResponse = {
  __typename?: "mutation_root";
  update_bookmark_folders?: {
    __typename?: "bookmark_folders_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "bookmark_folders";
      color?: string | null;
      created_at?: any | null;
      id: any;
      is_default?: boolean | null;
      is_favorite?: boolean | null;
      name: string;
      parent_id?: any | null;
      path?: any | null;
      position?: number | null;
      updated_at?: any | null;
      user_id: any;
      bookmarks: Array<{
        __typename?: "bookmarks";
        content_id: any;
        content_type: string;
        created_at?: any | null;
        folder_id?: any | null;
        id: any;
        metadata?: any | null;
        updated_at?: any | null;
        user_id: any;
      }>;
    }>;
  } | null;
};

export type UpdateOneBookmarkFolderVariables = Exact<{
  _inc?: InputMaybe<BookmarkFoldersIncInput>;
  _set?: InputMaybe<BookmarkFoldersSetInput>;
  pk_columns: BookmarkFoldersPkColumnsInput;
}>;

export type UpdateOneBookmarkFolderResponse = {
  __typename?: "mutation_root";
  update_bookmark_folders_by_pk?: {
    __typename?: "bookmark_folders";
    color?: string | null;
    created_at?: any | null;
    id: any;
    is_default?: boolean | null;
    is_favorite?: boolean | null;
    name: string;
    parent_id?: any | null;
    path?: any | null;
    position?: number | null;
    updated_at?: any | null;
    user_id: any;
    bookmarks: Array<{
      __typename?: "bookmarks";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      folder_id?: any | null;
      id: any;
      metadata?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  } | null;
};

export type UpdateManyBookmarkFoldersManyVariables = Exact<{
  updates: Array<BookmarkFoldersUpdates> | BookmarkFoldersUpdates;
}>;

export type UpdateManyBookmarkFoldersManyResponse = {
  __typename?: "mutation_root";
  update_bookmark_folders_many?: Array<{
    __typename?: "bookmark_folders_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "bookmark_folders";
      color?: string | null;
      created_at?: any | null;
      id: any;
      is_default?: boolean | null;
      is_favorite?: boolean | null;
      name: string;
      parent_id?: any | null;
      path?: any | null;
      position?: number | null;
      updated_at?: any | null;
      user_id: any;
      bookmarks: Array<{
        __typename?: "bookmarks";
        content_id: any;
        content_type: string;
        created_at?: any | null;
        folder_id?: any | null;
        id: any;
        metadata?: any | null;
        updated_at?: any | null;
        user_id: any;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyBookmarkVariables = Exact<{
  _append?: InputMaybe<BookmarksAppendInput>;
  _delete_at_path?: InputMaybe<BookmarksDeleteAtPathInput>;
  _delete_elem?: InputMaybe<BookmarksDeleteElemInput>;
  _delete_key?: InputMaybe<BookmarksDeleteKeyInput>;
  _prepend?: InputMaybe<BookmarksPrependInput>;
  _set?: InputMaybe<BookmarksSetInput>;
  where: BookmarksBoolExp;
}>;

export type UpdateManyBookmarkResponse = {
  __typename?: "mutation_root";
  update_bookmarks?: {
    __typename?: "bookmarks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "bookmarks";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      folder_id?: any | null;
      id: any;
      metadata?: any | null;
      updated_at?: any | null;
      user_id: any;
      bookmark_folder?: {
        __typename?: "bookmark_folders";
        color?: string | null;
        created_at?: any | null;
        id: any;
        is_default?: boolean | null;
        is_favorite?: boolean | null;
        name: string;
        parent_id?: any | null;
        path?: any | null;
        position?: number | null;
        updated_at?: any | null;
        user_id: any;
      } | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null;
};

export type UpdateOneBookmarkVariables = Exact<{
  _append?: InputMaybe<BookmarksAppendInput>;
  _delete_at_path?: InputMaybe<BookmarksDeleteAtPathInput>;
  _delete_elem?: InputMaybe<BookmarksDeleteElemInput>;
  _delete_key?: InputMaybe<BookmarksDeleteKeyInput>;
  _prepend?: InputMaybe<BookmarksPrependInput>;
  _set?: InputMaybe<BookmarksSetInput>;
  pk_columns: BookmarksPkColumnsInput;
}>;

export type UpdateOneBookmarkResponse = {
  __typename?: "mutation_root";
  update_bookmarks_by_pk?: {
    __typename?: "bookmarks";
    content_id: any;
    content_type: string;
    created_at?: any | null;
    folder_id?: any | null;
    id: any;
    metadata?: any | null;
    updated_at?: any | null;
    user_id: any;
    bookmark_folder?: {
      __typename?: "bookmark_folders";
      color?: string | null;
      created_at?: any | null;
      id: any;
      is_default?: boolean | null;
      is_favorite?: boolean | null;
      name: string;
      parent_id?: any | null;
      path?: any | null;
      position?: number | null;
      updated_at?: any | null;
      user_id: any;
    } | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type UpdateManyBookmarksManyVariables = Exact<{
  updates: Array<BookmarksUpdates> | BookmarksUpdates;
}>;

export type UpdateManyBookmarksManyResponse = {
  __typename?: "mutation_root";
  update_bookmarks_many?: Array<{
    __typename?: "bookmarks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "bookmarks";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      folder_id?: any | null;
      id: any;
      metadata?: any | null;
      updated_at?: any | null;
      user_id: any;
      bookmark_folder?: {
        __typename?: "bookmark_folders";
        color?: string | null;
        created_at?: any | null;
        id: any;
        is_default?: boolean | null;
        is_favorite?: boolean | null;
        name: string;
        parent_id?: any | null;
        path?: any | null;
        position?: number | null;
        updated_at?: any | null;
        user_id: any;
      } | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null> | null;
};

export type UpdateManyBusinessDomainVariables = Exact<{
  _set?: InputMaybe<BusinessDomainsSetInput>;
  where: BusinessDomainsBoolExp;
}>;

export type UpdateManyBusinessDomainResponse = {
  __typename?: "mutation_root";
  update_business_domains?: {
    __typename?: "business_domains_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "business_domains";
      created_at?: any | null;
      description?: string | null;
      id: any;
      name: string;
      parent_id?: any | null;
      slug: string;
      updated_at?: any | null;
      categorized_urls: Array<{
        __typename?: "categorized_urls";
        categorizer_version: string;
        company_id?: any | null;
        confidence: any;
        content_hash?: string | null;
        created_at?: any | null;
        domain_id: any;
        found_on?: string | null;
        id: any;
        priority?: any | null;
        updated_at?: any | null;
        url: string;
      }>;
    }>;
  } | null;
};

export type UpdateOneBusinessDomainVariables = Exact<{
  _set?: InputMaybe<BusinessDomainsSetInput>;
  pk_columns: BusinessDomainsPkColumnsInput;
}>;

export type UpdateOneBusinessDomainResponse = {
  __typename?: "mutation_root";
  update_business_domains_by_pk?: {
    __typename?: "business_domains";
    created_at?: any | null;
    description?: string | null;
    id: any;
    name: string;
    parent_id?: any | null;
    slug: string;
    updated_at?: any | null;
    categorized_urls: Array<{
      __typename?: "categorized_urls";
      categorizer_version: string;
      company_id?: any | null;
      confidence: any;
      content_hash?: string | null;
      created_at?: any | null;
      domain_id: any;
      found_on?: string | null;
      id: any;
      priority?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
  } | null;
};

export type UpdateManyBusinessDomainsManyVariables = Exact<{
  updates: Array<BusinessDomainsUpdates> | BusinessDomainsUpdates;
}>;

export type UpdateManyBusinessDomainsManyResponse = {
  __typename?: "mutation_root";
  update_business_domains_many?: Array<{
    __typename?: "business_domains_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "business_domains";
      created_at?: any | null;
      description?: string | null;
      id: any;
      name: string;
      parent_id?: any | null;
      slug: string;
      updated_at?: any | null;
      categorized_urls: Array<{
        __typename?: "categorized_urls";
        categorizer_version: string;
        company_id?: any | null;
        confidence: any;
        content_hash?: string | null;
        created_at?: any | null;
        domain_id: any;
        found_on?: string | null;
        id: any;
        priority?: any | null;
        updated_at?: any | null;
        url: string;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyCategoryVariables = Exact<{
  _inc?: InputMaybe<CategoriesIncInput>;
  _set?: InputMaybe<CategoriesSetInput>;
  where: CategoriesBoolExp;
}>;

export type UpdateManyCategoryResponse = {
  __typename?: "mutation_root";
  update_categories?: {
    __typename?: "categories_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
      companies: Array<{
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      }>;
      content_categories: Array<{
        __typename?: "content_categories";
        category_id: any;
        content_id: any;
        is_primary: boolean;
      }>;
      feed_categories: Array<{
        __typename?: "feed_categories";
        category_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      news: Array<{
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      }>;
    }>;
  } | null;
};

export type UpdateOneCategoryVariables = Exact<{
  _inc?: InputMaybe<CategoriesIncInput>;
  _set?: InputMaybe<CategoriesSetInput>;
  pk_columns: CategoriesPkColumnsInput;
}>;

export type UpdateOneCategoryResponse = {
  __typename?: "mutation_root";
  update_categories_by_pk?: {
    __typename?: "categories";
    body?: string | null;
    created_at: any;
    document_id?: string | null;
    id: any;
    locale?: string | null;
    name: string;
    published_at?: string | null;
    updated_at?: any | null;
    companies: Array<{
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    }>;
    content_categories: Array<{
      __typename?: "content_categories";
      category_id: any;
      content_id: any;
      is_primary: boolean;
    }>;
    feed_categories: Array<{
      __typename?: "feed_categories";
      category_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    news: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
  } | null;
};

export type UpdateManyCategoriesManyVariables = Exact<{
  updates: Array<CategoriesUpdates> | CategoriesUpdates;
}>;

export type UpdateManyCategoriesManyResponse = {
  __typename?: "mutation_root";
  update_categories_many?: Array<{
    __typename?: "categories_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
      companies: Array<{
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      }>;
      content_categories: Array<{
        __typename?: "content_categories";
        category_id: any;
        content_id: any;
        is_primary: boolean;
      }>;
      feed_categories: Array<{
        __typename?: "feed_categories";
        category_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      news: Array<{
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyCategorizedUrlVariables = Exact<{
  _inc?: InputMaybe<CategorizedUrlsIncInput>;
  _set?: InputMaybe<CategorizedUrlsSetInput>;
  where: CategorizedUrlsBoolExp;
}>;

export type UpdateManyCategorizedUrlResponse = {
  __typename?: "mutation_root";
  update_categorized_urls?: {
    __typename?: "categorized_urls_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "categorized_urls";
      categorizer_version: string;
      company_id?: any | null;
      confidence: any;
      content_hash?: string | null;
      created_at?: any | null;
      domain_id: any;
      found_on?: string | null;
      id: any;
      priority?: any | null;
      updated_at?: any | null;
      url: string;
      business_domain: {
        __typename?: "business_domains";
        created_at?: any | null;
        description?: string | null;
        id: any;
        name: string;
        parent_id?: any | null;
        slug: string;
        updated_at?: any | null;
      };
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null;
};

export type UpdateOneCategorizedUrlVariables = Exact<{
  _inc?: InputMaybe<CategorizedUrlsIncInput>;
  _set?: InputMaybe<CategorizedUrlsSetInput>;
  pk_columns: CategorizedUrlsPkColumnsInput;
}>;

export type UpdateOneCategorizedUrlResponse = {
  __typename?: "mutation_root";
  update_categorized_urls_by_pk?: {
    __typename?: "categorized_urls";
    categorizer_version: string;
    company_id?: any | null;
    confidence: any;
    content_hash?: string | null;
    created_at?: any | null;
    domain_id: any;
    found_on?: string | null;
    id: any;
    priority?: any | null;
    updated_at?: any | null;
    url: string;
    business_domain: {
      __typename?: "business_domains";
      created_at?: any | null;
      description?: string | null;
      id: any;
      name: string;
      parent_id?: any | null;
      slug: string;
      updated_at?: any | null;
    };
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type UpdateManyCategorizedUrlsManyVariables = Exact<{
  updates: Array<CategorizedUrlsUpdates> | CategorizedUrlsUpdates;
}>;

export type UpdateManyCategorizedUrlsManyResponse = {
  __typename?: "mutation_root";
  update_categorized_urls_many?: Array<{
    __typename?: "categorized_urls_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "categorized_urls";
      categorizer_version: string;
      company_id?: any | null;
      confidence: any;
      content_hash?: string | null;
      created_at?: any | null;
      domain_id: any;
      found_on?: string | null;
      id: any;
      priority?: any | null;
      updated_at?: any | null;
      url: string;
      business_domain: {
        __typename?: "business_domains";
        created_at?: any | null;
        description?: string | null;
        id: any;
        name: string;
        parent_id?: any | null;
        slug: string;
        updated_at?: any | null;
      };
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyCircuitBreakerStateVariables = Exact<{
  _inc?: InputMaybe<CircuitBreakerStatesIncInput>;
  _set?: InputMaybe<CircuitBreakerStatesSetInput>;
  where: CircuitBreakerStatesBoolExp;
}>;

export type UpdateManyCircuitBreakerStateResponse = {
  __typename?: "mutation_root";
  update_circuit_breaker_states?: {
    __typename?: "circuit_breaker_states_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "circuit_breaker_states";
      created_at?: any | null;
      failure_count?: number | null;
      id: any;
      job_name: string;
      last_failure?: any | null;
      last_success?: any | null;
      state: string;
      updated_at?: any | null;
    }>;
  } | null;
};

export type UpdateOneCircuitBreakerStateVariables = Exact<{
  _inc?: InputMaybe<CircuitBreakerStatesIncInput>;
  _set?: InputMaybe<CircuitBreakerStatesSetInput>;
  pk_columns: CircuitBreakerStatesPkColumnsInput;
}>;

export type UpdateOneCircuitBreakerStateResponse = {
  __typename?: "mutation_root";
  update_circuit_breaker_states_by_pk?: {
    __typename?: "circuit_breaker_states";
    created_at?: any | null;
    failure_count?: number | null;
    id: any;
    job_name: string;
    last_failure?: any | null;
    last_success?: any | null;
    state: string;
    updated_at?: any | null;
  } | null;
};

export type UpdateManyCircuitBreakerStatesManyVariables = Exact<{
  updates: Array<CircuitBreakerStatesUpdates> | CircuitBreakerStatesUpdates;
}>;

export type UpdateManyCircuitBreakerStatesManyResponse = {
  __typename?: "mutation_root";
  update_circuit_breaker_states_many?: Array<{
    __typename?: "circuit_breaker_states_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "circuit_breaker_states";
      created_at?: any | null;
      failure_count?: number | null;
      id: any;
      job_name: string;
      last_failure?: any | null;
      last_success?: any | null;
      state: string;
      updated_at?: any | null;
    }>;
  } | null> | null;
};

export type UpdateManyCityVariables = Exact<{
  _inc?: InputMaybe<CitiesIncInput>;
  _set?: InputMaybe<CitiesSetInput>;
  where: CitiesBoolExp;
}>;

export type UpdateManyCityResponse = {
  __typename?: "mutation_root";
  update_cities?: {
    __typename?: "cities_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "cities";
      country_id: number;
      id: number;
      name: string;
      state?: string | null;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      country: {
        __typename?: "countries";
        code: string;
        code_3?: string | null;
        id: number;
        name: string;
      };
    }>;
  } | null;
};

export type UpdateOneCityVariables = Exact<{
  _inc?: InputMaybe<CitiesIncInput>;
  _set?: InputMaybe<CitiesSetInput>;
  pk_columns: CitiesPkColumnsInput;
}>;

export type UpdateOneCityResponse = {
  __typename?: "mutation_root";
  update_cities_by_pk?: {
    __typename?: "cities";
    country_id: number;
    id: number;
    name: string;
    state?: string | null;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    country: {
      __typename?: "countries";
      code: string;
      code_3?: string | null;
      id: number;
      name: string;
    };
  } | null;
};

export type UpdateManyCitiesManyVariables = Exact<{
  updates: Array<CitiesUpdates> | CitiesUpdates;
}>;

export type UpdateManyCitiesManyResponse = {
  __typename?: "mutation_root";
  update_cities_many?: Array<{
    __typename?: "cities_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "cities";
      country_id: number;
      id: number;
      name: string;
      state?: string | null;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      country: {
        __typename?: "countries";
        code: string;
        code_3?: string | null;
        id: number;
        name: string;
      };
    }>;
  } | null> | null;
};

export type UpdateManyCommentVariables = Exact<{
  _set?: InputMaybe<CommentsSetInput>;
  where: CommentsBoolExp;
}>;

export type UpdateManyCommentResponse = {
  __typename?: "mutation_root";
  update_comments?: {
    __typename?: "comments_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "comments";
      content: string;
      content_id: any;
      content_type: any;
      created_at?: any | null;
      id: any;
      parent_comment_id?: any | null;
      updated_at?: any | null;
      user_id: any;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneCommentVariables = Exact<{
  _set?: InputMaybe<CommentsSetInput>;
  pk_columns: CommentsPkColumnsInput;
}>;

export type UpdateOneCommentResponse = {
  __typename?: "mutation_root";
  update_comments_by_pk?: {
    __typename?: "comments";
    content: string;
    content_id: any;
    content_type: any;
    created_at?: any | null;
    id: any;
    parent_comment_id?: any | null;
    updated_at?: any | null;
    user_id: any;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type UpdateManyCommentsManyVariables = Exact<{
  updates: Array<CommentsUpdates> | CommentsUpdates;
}>;

export type UpdateManyCommentsManyResponse = {
  __typename?: "mutation_root";
  update_comments_many?: Array<{
    __typename?: "comments_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "comments";
      content: string;
      content_id: any;
      content_type: any;
      created_at?: any | null;
      id: any;
      parent_comment_id?: any | null;
      updated_at?: any | null;
      user_id: any;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyCompanyVariables = Exact<{
  _append?: InputMaybe<CompaniesAppendInput>;
  _delete_at_path?: InputMaybe<CompaniesDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CompaniesDeleteElemInput>;
  _delete_key?: InputMaybe<CompaniesDeleteKeyInput>;
  _inc?: InputMaybe<CompaniesIncInput>;
  _prepend?: InputMaybe<CompaniesPrependInput>;
  _set?: InputMaybe<CompaniesSetInput>;
  where: CompaniesBoolExp;
}>;

export type UpdateManyCompanyResponse = {
  __typename?: "mutation_root";
  update_companies?: {
    __typename?: "companies_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      ads: Array<{
        __typename?: "ads";
        active?: boolean | null;
        company_id?: any | null;
        created_at?: any | null;
        end_date: any;
        id: any;
        package_id?: any | null;
        start_date: any;
        updated_at?: any | null;
      }>;
      blacklisted_urls: Array<{
        __typename?: "blacklisted_urls";
        company_id?: any | null;
        created_at?: any | null;
        id: number;
        reason?: string | null;
        url: string;
      }>;
      categorized_urls: Array<{
        __typename?: "categorized_urls";
        categorizer_version: string;
        company_id?: any | null;
        confidence: any;
        content_hash?: string | null;
        created_at?: any | null;
        domain_id: any;
        found_on?: string | null;
        id: any;
        priority?: any | null;
        updated_at?: any | null;
        url: string;
      }>;
      categoryByCategoryId?: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      } | null;
      company_contacts: Array<{
        __typename?: "company_contacts";
        company_id?: any | null;
        contact_id: number;
        created_at: any;
        id: number;
        updated_at: any;
      }>;
      company_extras: Array<{
        __typename?: "company_extras";
        body?: string | null;
        category: string;
        company_id?: any | null;
        created_at: any;
        found_count?: number | null;
        id: number;
        level: any;
        review?: any | null;
        success?: boolean | null;
        updated_at: any;
        url: string;
      }>;
      contacts: Array<{
        __typename?: "contacts";
        company_id?: any | null;
        contact_type?: any | null;
        created_at?: any | null;
        email?: string | null;
        id: number;
        is_primary?: boolean | null;
        phone?: string | null;
        privacy_level?: any | null;
        title?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      content_sources: Array<{
        __typename?: "content_sources";
        company_id?: any | null;
        content_type: any;
        created_at?: any | null;
        expected_count?: any | null;
        failed_count?: any | null;
        has_failed?: boolean | null;
        hash?: any | null;
        id: any;
        priority: any;
        refreshed_at?: any | null;
        rss_urls?: Array<string> | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        updated_at?: any | null;
        url: string;
      }>;
      news: Array<{
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      }>;
      social_medium?: {
        __typename?: "social_media";
        created_at?: any | null;
        facebook_url?: string | null;
        id: number;
        instagram_url?: string | null;
        linkedin_url?: string | null;
        twitter_url?: string | null;
        updated_at?: any | null;
        youtube_url?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneCompanyVariables = Exact<{
  _append?: InputMaybe<CompaniesAppendInput>;
  _delete_at_path?: InputMaybe<CompaniesDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CompaniesDeleteElemInput>;
  _delete_key?: InputMaybe<CompaniesDeleteKeyInput>;
  _inc?: InputMaybe<CompaniesIncInput>;
  _prepend?: InputMaybe<CompaniesPrependInput>;
  _set?: InputMaybe<CompaniesSetInput>;
  pk_columns: CompaniesPkColumnsInput;
}>;

export type UpdateOneCompanyResponse = {
  __typename?: "mutation_root";
  update_companies_by_pk?: {
    __typename?: "companies";
    category?: string | null;
    category_id?: any | null;
    content_status: any;
    created_at?: any | null;
    description?: string | null;
    failed_count?: any | null;
    founding_year?: any | null;
    id: any;
    is_english?: boolean | null;
    is_government?: boolean | null;
    keywords?: any | null;
    logo_url?: string | null;
    name?: string | null;
    scrape_frequency?: any | null;
    scrape_rating?: any | null;
    scraped_at?: any | null;
    social_media_id?: number | null;
    updated_at?: any | null;
    url: string;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    ads: Array<{
      __typename?: "ads";
      active?: boolean | null;
      company_id?: any | null;
      created_at?: any | null;
      end_date: any;
      id: any;
      package_id?: any | null;
      start_date: any;
      updated_at?: any | null;
    }>;
    blacklisted_urls: Array<{
      __typename?: "blacklisted_urls";
      company_id?: any | null;
      created_at?: any | null;
      id: number;
      reason?: string | null;
      url: string;
    }>;
    categorized_urls: Array<{
      __typename?: "categorized_urls";
      categorizer_version: string;
      company_id?: any | null;
      confidence: any;
      content_hash?: string | null;
      created_at?: any | null;
      domain_id: any;
      found_on?: string | null;
      id: any;
      priority?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
    categoryByCategoryId?: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    } | null;
    company_contacts: Array<{
      __typename?: "company_contacts";
      company_id?: any | null;
      contact_id: number;
      created_at: any;
      id: number;
      updated_at: any;
    }>;
    company_extras: Array<{
      __typename?: "company_extras";
      body?: string | null;
      category: string;
      company_id?: any | null;
      created_at: any;
      found_count?: number | null;
      id: number;
      level: any;
      review?: any | null;
      success?: boolean | null;
      updated_at: any;
      url: string;
    }>;
    contacts: Array<{
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    content_sources: Array<{
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    }>;
    news: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
    social_medium?: {
      __typename?: "social_media";
      created_at?: any | null;
      facebook_url?: string | null;
      id: number;
      instagram_url?: string | null;
      linkedin_url?: string | null;
      twitter_url?: string | null;
      updated_at?: any | null;
      youtube_url?: string | null;
    } | null;
  } | null;
};

export type UpdateManyCompaniesManyVariables = Exact<{
  updates: Array<CompaniesUpdates> | CompaniesUpdates;
}>;

export type UpdateManyCompaniesManyResponse = {
  __typename?: "mutation_root";
  update_companies_many?: Array<{
    __typename?: "companies_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      ads: Array<{
        __typename?: "ads";
        active?: boolean | null;
        company_id?: any | null;
        created_at?: any | null;
        end_date: any;
        id: any;
        package_id?: any | null;
        start_date: any;
        updated_at?: any | null;
      }>;
      blacklisted_urls: Array<{
        __typename?: "blacklisted_urls";
        company_id?: any | null;
        created_at?: any | null;
        id: number;
        reason?: string | null;
        url: string;
      }>;
      categorized_urls: Array<{
        __typename?: "categorized_urls";
        categorizer_version: string;
        company_id?: any | null;
        confidence: any;
        content_hash?: string | null;
        created_at?: any | null;
        domain_id: any;
        found_on?: string | null;
        id: any;
        priority?: any | null;
        updated_at?: any | null;
        url: string;
      }>;
      categoryByCategoryId?: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      } | null;
      company_contacts: Array<{
        __typename?: "company_contacts";
        company_id?: any | null;
        contact_id: number;
        created_at: any;
        id: number;
        updated_at: any;
      }>;
      company_extras: Array<{
        __typename?: "company_extras";
        body?: string | null;
        category: string;
        company_id?: any | null;
        created_at: any;
        found_count?: number | null;
        id: number;
        level: any;
        review?: any | null;
        success?: boolean | null;
        updated_at: any;
        url: string;
      }>;
      contacts: Array<{
        __typename?: "contacts";
        company_id?: any | null;
        contact_type?: any | null;
        created_at?: any | null;
        email?: string | null;
        id: number;
        is_primary?: boolean | null;
        phone?: string | null;
        privacy_level?: any | null;
        title?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      content_sources: Array<{
        __typename?: "content_sources";
        company_id?: any | null;
        content_type: any;
        created_at?: any | null;
        expected_count?: any | null;
        failed_count?: any | null;
        has_failed?: boolean | null;
        hash?: any | null;
        id: any;
        priority: any;
        refreshed_at?: any | null;
        rss_urls?: Array<string> | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        updated_at?: any | null;
        url: string;
      }>;
      news: Array<{
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      }>;
      social_medium?: {
        __typename?: "social_media";
        created_at?: any | null;
        facebook_url?: string | null;
        id: number;
        instagram_url?: string | null;
        linkedin_url?: string | null;
        twitter_url?: string | null;
        updated_at?: any | null;
        youtube_url?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyCompanyContactVariables = Exact<{
  _inc?: InputMaybe<CompanyContactsIncInput>;
  _set?: InputMaybe<CompanyContactsSetInput>;
  where: CompanyContactsBoolExp;
}>;

export type UpdateManyCompanyContactResponse = {
  __typename?: "mutation_root";
  update_company_contacts?: {
    __typename?: "company_contacts_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_contacts";
      company_id?: any | null;
      contact_id: number;
      created_at: any;
      id: number;
      updated_at: any;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      contact: {
        __typename?: "contacts";
        company_id?: any | null;
        contact_type?: any | null;
        created_at?: any | null;
        email?: string | null;
        id: number;
        is_primary?: boolean | null;
        phone?: string | null;
        privacy_level?: any | null;
        title?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      };
    }>;
  } | null;
};

export type UpdateOneCompanyContactVariables = Exact<{
  _inc?: InputMaybe<CompanyContactsIncInput>;
  _set?: InputMaybe<CompanyContactsSetInput>;
  pk_columns: CompanyContactsPkColumnsInput;
}>;

export type UpdateOneCompanyContactResponse = {
  __typename?: "mutation_root";
  update_company_contacts_by_pk?: {
    __typename?: "company_contacts";
    company_id?: any | null;
    contact_id: number;
    created_at: any;
    id: number;
    updated_at: any;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    contact: {
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    };
  } | null;
};

export type UpdateManyCompanyContactsManyVariables = Exact<{
  updates: Array<CompanyContactsUpdates> | CompanyContactsUpdates;
}>;

export type UpdateManyCompanyContactsManyResponse = {
  __typename?: "mutation_root";
  update_company_contacts_many?: Array<{
    __typename?: "company_contacts_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_contacts";
      company_id?: any | null;
      contact_id: number;
      created_at: any;
      id: number;
      updated_at: any;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      contact: {
        __typename?: "contacts";
        company_id?: any | null;
        contact_type?: any | null;
        created_at?: any | null;
        email?: string | null;
        id: number;
        is_primary?: boolean | null;
        phone?: string | null;
        privacy_level?: any | null;
        title?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyCompanyEmployeeVariables = Exact<{
  _set?: InputMaybe<CompanyEmployeesSetInput>;
  where: CompanyEmployeesBoolExp;
}>;

export type UpdateManyCompanyEmployeeResponse = {
  __typename?: "mutation_root";
  update_company_employees?: {
    __typename?: "company_employees_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_employees";
      access_level: any;
      company_id?: any | null;
      created_at?: any | null;
      end_date?: any | null;
      id: any;
      job_description?: string | null;
      role: string;
      start_date?: any | null;
      status?: boolean | null;
      updated_at?: any | null;
      user_id: any;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneCompanyEmployeeVariables = Exact<{
  _set?: InputMaybe<CompanyEmployeesSetInput>;
  pk_columns: CompanyEmployeesPkColumnsInput;
}>;

export type UpdateOneCompanyEmployeeResponse = {
  __typename?: "mutation_root";
  update_company_employees_by_pk?: {
    __typename?: "company_employees";
    access_level: any;
    company_id?: any | null;
    created_at?: any | null;
    end_date?: any | null;
    id: any;
    job_description?: string | null;
    role: string;
    start_date?: any | null;
    status?: boolean | null;
    updated_at?: any | null;
    user_id: any;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type UpdateManyCompanyEmployeesManyVariables = Exact<{
  updates: Array<CompanyEmployeesUpdates> | CompanyEmployeesUpdates;
}>;

export type UpdateManyCompanyEmployeesManyResponse = {
  __typename?: "mutation_root";
  update_company_employees_many?: Array<{
    __typename?: "company_employees_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_employees";
      access_level: any;
      company_id?: any | null;
      created_at?: any | null;
      end_date?: any | null;
      id: any;
      job_description?: string | null;
      role: string;
      start_date?: any | null;
      status?: boolean | null;
      updated_at?: any | null;
      user_id: any;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyCompanyExtraVariables = Exact<{
  _append?: InputMaybe<CompanyExtrasAppendInput>;
  _delete_at_path?: InputMaybe<CompanyExtrasDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CompanyExtrasDeleteElemInput>;
  _delete_key?: InputMaybe<CompanyExtrasDeleteKeyInput>;
  _inc?: InputMaybe<CompanyExtrasIncInput>;
  _prepend?: InputMaybe<CompanyExtrasPrependInput>;
  _set?: InputMaybe<CompanyExtrasSetInput>;
  where: CompanyExtrasBoolExp;
}>;

export type UpdateManyCompanyExtraResponse = {
  __typename?: "mutation_root";
  update_company_extras?: {
    __typename?: "company_extras_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_extras";
      body?: string | null;
      category: string;
      company_id?: any | null;
      created_at: any;
      found_count?: number | null;
      id: number;
      level: any;
      review?: any | null;
      success?: boolean | null;
      updated_at: any;
      url: string;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null;
};

export type UpdateOneCompanyExtraVariables = Exact<{
  _append?: InputMaybe<CompanyExtrasAppendInput>;
  _delete_at_path?: InputMaybe<CompanyExtrasDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CompanyExtrasDeleteElemInput>;
  _delete_key?: InputMaybe<CompanyExtrasDeleteKeyInput>;
  _inc?: InputMaybe<CompanyExtrasIncInput>;
  _prepend?: InputMaybe<CompanyExtrasPrependInput>;
  _set?: InputMaybe<CompanyExtrasSetInput>;
  pk_columns: CompanyExtrasPkColumnsInput;
}>;

export type UpdateOneCompanyExtraResponse = {
  __typename?: "mutation_root";
  update_company_extras_by_pk?: {
    __typename?: "company_extras";
    body?: string | null;
    category: string;
    company_id?: any | null;
    created_at: any;
    found_count?: number | null;
    id: number;
    level: any;
    review?: any | null;
    success?: boolean | null;
    updated_at: any;
    url: string;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
  } | null;
};

export type UpdateManyCompanyExtrasManyVariables = Exact<{
  updates: Array<CompanyExtrasUpdates> | CompanyExtrasUpdates;
}>;

export type UpdateManyCompanyExtrasManyResponse = {
  __typename?: "mutation_root";
  update_company_extras_many?: Array<{
    __typename?: "company_extras_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_extras";
      body?: string | null;
      category: string;
      company_id?: any | null;
      created_at: any;
      found_count?: number | null;
      id: number;
      level: any;
      review?: any | null;
      success?: boolean | null;
      updated_at: any;
      url: string;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyCompanyMetricVariables = Exact<{
  _append?: InputMaybe<CompanyMetricsAppendInput>;
  _delete_at_path?: InputMaybe<CompanyMetricsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CompanyMetricsDeleteElemInput>;
  _delete_key?: InputMaybe<CompanyMetricsDeleteKeyInput>;
  _inc?: InputMaybe<CompanyMetricsIncInput>;
  _prepend?: InputMaybe<CompanyMetricsPrependInput>;
  _set?: InputMaybe<CompanyMetricsSetInput>;
  where: CompanyMetricsBoolExp;
}>;

export type UpdateManyCompanyMetricResponse = {
  __typename?: "mutation_root";
  update_company_metrics?: {
    __typename?: "company_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_metrics";
      company_id: any;
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
      metric_definition?: {
        __typename?: "metric_definitions";
        category?: string | null;
        description?: string | null;
        id: number;
        is_dimensional?: boolean | null;
        name: string;
        type: string;
        unit?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneCompanyMetricVariables = Exact<{
  _append?: InputMaybe<CompanyMetricsAppendInput>;
  _delete_at_path?: InputMaybe<CompanyMetricsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CompanyMetricsDeleteElemInput>;
  _delete_key?: InputMaybe<CompanyMetricsDeleteKeyInput>;
  _inc?: InputMaybe<CompanyMetricsIncInput>;
  _prepend?: InputMaybe<CompanyMetricsPrependInput>;
  _set?: InputMaybe<CompanyMetricsSetInput>;
  pk_columns: CompanyMetricsPkColumnsInput;
}>;

export type UpdateOneCompanyMetricResponse = {
  __typename?: "mutation_root";
  update_company_metrics_by_pk?: {
    __typename?: "company_metrics";
    company_id: any;
    crawl_id: any;
    id: any;
    metric_id?: number | null;
    timestamp: any;
    value: any;
    metric_definition?: {
      __typename?: "metric_definitions";
      category?: string | null;
      description?: string | null;
      id: number;
      is_dimensional?: boolean | null;
      name: string;
      type: string;
      unit?: string | null;
    } | null;
  } | null;
};

export type UpdateManyCompanyMetricsManyVariables = Exact<{
  updates: Array<CompanyMetricsUpdates> | CompanyMetricsUpdates;
}>;

export type UpdateManyCompanyMetricsManyResponse = {
  __typename?: "mutation_root";
  update_company_metrics_many?: Array<{
    __typename?: "company_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "company_metrics";
      company_id: any;
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
      metric_definition?: {
        __typename?: "metric_definitions";
        category?: string | null;
        description?: string | null;
        id: number;
        is_dimensional?: boolean | null;
        name: string;
        type: string;
        unit?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyContactVariables = Exact<{
  _inc?: InputMaybe<ContactsIncInput>;
  _set?: InputMaybe<ContactsSetInput>;
  where: ContactsBoolExp;
}>;

export type UpdateManyContactResponse = {
  __typename?: "mutation_root";
  update_contacts?: {
    __typename?: "contacts_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      company_contacts: Array<{
        __typename?: "company_contacts";
        company_id?: any | null;
        contact_id: number;
        created_at: any;
        id: number;
        updated_at: any;
      }>;
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneContactVariables = Exact<{
  _inc?: InputMaybe<ContactsIncInput>;
  _set?: InputMaybe<ContactsSetInput>;
  pk_columns: ContactsPkColumnsInput;
}>;

export type UpdateOneContactResponse = {
  __typename?: "mutation_root";
  update_contacts_by_pk?: {
    __typename?: "contacts";
    company_id?: any | null;
    contact_type?: any | null;
    created_at?: any | null;
    email?: string | null;
    id: number;
    is_primary?: boolean | null;
    phone?: string | null;
    privacy_level?: any | null;
    title?: string | null;
    updated_at?: any | null;
    user_id?: any | null;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    company_contacts: Array<{
      __typename?: "company_contacts";
      company_id?: any | null;
      contact_id: number;
      created_at: any;
      id: number;
      updated_at: any;
    }>;
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type UpdateManyContactsManyVariables = Exact<{
  updates: Array<ContactsUpdates> | ContactsUpdates;
}>;

export type UpdateManyContactsManyResponse = {
  __typename?: "mutation_root";
  update_contacts_many?: Array<{
    __typename?: "contacts_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      company_contacts: Array<{
        __typename?: "company_contacts";
        company_id?: any | null;
        contact_id: number;
        created_at: any;
        id: number;
        updated_at: any;
      }>;
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyContentCategoryVariables = Exact<{
  _inc?: InputMaybe<ContentCategoriesIncInput>;
  _set?: InputMaybe<ContentCategoriesSetInput>;
  where: ContentCategoriesBoolExp;
}>;

export type UpdateManyContentCategoryResponse = {
  __typename?: "mutation_root";
  update_content_categories?: {
    __typename?: "content_categories_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_categories";
      category_id: any;
      content_id: any;
      is_primary: boolean;
      category: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      };
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null;
};

export type UpdateOneContentCategoryVariables = Exact<{
  _inc?: InputMaybe<ContentCategoriesIncInput>;
  _set?: InputMaybe<ContentCategoriesSetInput>;
  pk_columns: ContentCategoriesPkColumnsInput;
}>;

export type UpdateOneContentCategoryResponse = {
  __typename?: "mutation_root";
  update_content_categories_by_pk?: {
    __typename?: "content_categories";
    category_id: any;
    content_id: any;
    is_primary: boolean;
    category: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    };
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type UpdateManyContentCategoriesManyVariables = Exact<{
  updates: Array<ContentCategoriesUpdates> | ContentCategoriesUpdates;
}>;

export type UpdateManyContentCategoriesManyResponse = {
  __typename?: "mutation_root";
  update_content_categories_many?: Array<{
    __typename?: "content_categories_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_categories";
      category_id: any;
      content_id: any;
      is_primary: boolean;
      category: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      };
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null> | null;
};

export type UpdateManyContentSourceVisitVariables = Exact<{
  _set?: InputMaybe<ContentSourceVisitsSetInput>;
  where: ContentSourceVisitsBoolExp;
}>;

export type UpdateManyContentSourceVisitResponse = {
  __typename?: "mutation_root";
  update_content_source_visits?: {
    __typename?: "content_source_visits_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_source_visits";
      content_id: any;
      created_at?: any | null;
      id: any;
      user_id?: any | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneContentSourceVisitVariables = Exact<{
  _set?: InputMaybe<ContentSourceVisitsSetInput>;
  pk_columns: ContentSourceVisitsPkColumnsInput;
}>;

export type UpdateOneContentSourceVisitResponse = {
  __typename?: "mutation_root";
  update_content_source_visits_by_pk?: {
    __typename?: "content_source_visits";
    content_id: any;
    created_at?: any | null;
    id: any;
    user_id?: any | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type UpdateManyContentSourceVisitsManyVariables = Exact<{
  updates: Array<ContentSourceVisitsUpdates> | ContentSourceVisitsUpdates;
}>;

export type UpdateManyContentSourceVisitsManyResponse = {
  __typename?: "mutation_root";
  update_content_source_visits_many?: Array<{
    __typename?: "content_source_visits_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_source_visits";
      content_id: any;
      created_at?: any | null;
      id: any;
      user_id?: any | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyContentSourceVariables = Exact<{
  _inc?: InputMaybe<ContentSourcesIncInput>;
  _set?: InputMaybe<ContentSourcesSetInput>;
  where: ContentSourcesBoolExp;
}>;

export type UpdateManyContentSourceResponse = {
  __typename?: "mutation_root";
  update_content_sources?: {
    __typename?: "content_sources_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      feed_sources: Array<{
        __typename?: "feed_sources";
        content_source_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      news: Array<{
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      }>;
    }>;
  } | null;
};

export type UpdateOneContentSourceVariables = Exact<{
  _inc?: InputMaybe<ContentSourcesIncInput>;
  _set?: InputMaybe<ContentSourcesSetInput>;
  pk_columns: ContentSourcesPkColumnsInput;
}>;

export type UpdateOneContentSourceResponse = {
  __typename?: "mutation_root";
  update_content_sources_by_pk?: {
    __typename?: "content_sources";
    company_id?: any | null;
    content_type: any;
    created_at?: any | null;
    expected_count?: any | null;
    failed_count?: any | null;
    has_failed?: boolean | null;
    hash?: any | null;
    id: any;
    priority: any;
    refreshed_at?: any | null;
    rss_urls?: Array<string> | null;
    scrape_frequency: any;
    scraped_at?: any | null;
    updated_at?: any | null;
    url: string;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    feed_sources: Array<{
      __typename?: "feed_sources";
      content_source_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    news: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    }>;
  } | null;
};

export type UpdateManyContentSourcesManyVariables = Exact<{
  updates: Array<ContentSourcesUpdates> | ContentSourcesUpdates;
}>;

export type UpdateManyContentSourcesManyResponse = {
  __typename?: "mutation_root";
  update_content_sources_many?: Array<{
    __typename?: "content_sources_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      feed_sources: Array<{
        __typename?: "feed_sources";
        content_source_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      news: Array<{
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyContentStatusVariables = Exact<{
  _set?: InputMaybe<ContentStatusesSetInput>;
  where: ContentStatusesBoolExp;
}>;

export type UpdateManyContentStatusResponse = {
  __typename?: "mutation_root";
  update_content_statuses?: {
    __typename?: "content_statuses_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_statuses";
      content_id: any;
      content_status: any;
      created_at?: any | null;
      id: any;
      notes?: string | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null;
};

export type UpdateOneContentStatusVariables = Exact<{
  _set?: InputMaybe<ContentStatusesSetInput>;
  pk_columns: ContentStatusesPkColumnsInput;
}>;

export type UpdateOneContentStatusResponse = {
  __typename?: "mutation_root";
  update_content_statuses_by_pk?: {
    __typename?: "content_statuses";
    content_id: any;
    content_status: any;
    created_at?: any | null;
    id: any;
    notes?: string | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type UpdateManyContentStatusesManyVariables = Exact<{
  updates: Array<ContentStatusesUpdates> | ContentStatusesUpdates;
}>;

export type UpdateManyContentStatusesManyResponse = {
  __typename?: "mutation_root";
  update_content_statuses_many?: Array<{
    __typename?: "content_statuses_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_statuses";
      content_id: any;
      content_status: any;
      created_at?: any | null;
      id: any;
      notes?: string | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null> | null;
};

export type UpdateManyContentTagVariables = Exact<{
  _inc?: InputMaybe<ContentTagsIncInput>;
  _set?: InputMaybe<ContentTagsSetInput>;
  where: ContentTagsBoolExp;
}>;

export type UpdateManyContentTagResponse = {
  __typename?: "mutation_root";
  update_content_tags?: {
    __typename?: "content_tags_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_tags";
      content_id: any;
      tag_id: number;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      tag: {
        __typename?: "tags";
        body?: string | null;
        created_at?: any | null;
        document_id?: string | null;
        id: number;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      };
    }>;
  } | null;
};

export type UpdateOneContentTagVariables = Exact<{
  _inc?: InputMaybe<ContentTagsIncInput>;
  _set?: InputMaybe<ContentTagsSetInput>;
  pk_columns: ContentTagsPkColumnsInput;
}>;

export type UpdateOneContentTagResponse = {
  __typename?: "mutation_root";
  update_content_tags_by_pk?: {
    __typename?: "content_tags";
    content_id: any;
    tag_id: number;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    tag: {
      __typename?: "tags";
      body?: string | null;
      created_at?: any | null;
      document_id?: string | null;
      id: number;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    };
  } | null;
};

export type UpdateManyContentTagsManyVariables = Exact<{
  updates: Array<ContentTagsUpdates> | ContentTagsUpdates;
}>;

export type UpdateManyContentTagsManyResponse = {
  __typename?: "mutation_root";
  update_content_tags_many?: Array<{
    __typename?: "content_tags_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "content_tags";
      content_id: any;
      tag_id: number;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      tag: {
        __typename?: "tags";
        body?: string | null;
        created_at?: any | null;
        document_id?: string | null;
        id: number;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyContentVariables = Exact<{
  _inc?: InputMaybe<ContentsIncInput>;
  _set?: InputMaybe<ContentsSetInput>;
  where: ContentsBoolExp;
}>;

export type UpdateManyContentResponse = {
  __typename?: "mutation_root";
  update_contents?: {
    __typename?: "contents_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
      bookmarks: Array<{
        __typename?: "bookmarks";
        content_id: any;
        content_type: string;
        created_at?: any | null;
        folder_id?: any | null;
        id: any;
        metadata?: any | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      content_categories: Array<{
        __typename?: "content_categories";
        category_id: any;
        content_id: any;
        is_primary: boolean;
      }>;
      content_source_visits: Array<{
        __typename?: "content_source_visits";
        content_id: any;
        created_at?: any | null;
        id: any;
        user_id?: any | null;
      }>;
      content_statuses: Array<{
        __typename?: "content_statuses";
        content_id: any;
        content_status: any;
        created_at?: any | null;
        id: any;
        notes?: string | null;
      }>;
      content_tags: Array<{
        __typename?: "content_tags";
        content_id: any;
        tag_id: number;
      }>;
      news?: {
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      } | null;
      newsletter?: {
        __typename?: "newsletters";
        content_status: any;
        created_at?: any | null;
        end_date: any;
        frequency: string;
        generated_content?: string | null;
        id: any;
        start_date: any;
        title: string;
        updated_at?: any | null;
      } | null;
      research?: {
        __typename?: "research";
        abstract?: string | null;
        abstract_url: string;
        affiliations?: any | null;
        authors?: any | null;
        category?: string | null;
        comments?: string | null;
        content_status: any;
        created_at: any;
        doi_url?: string | null;
        figure_count?: any | null;
        has_embedding?: boolean | null;
        id: any;
        is_flagged: boolean;
        keywords?: string | null;
        month?: string | null;
        page_count?: any | null;
        pdf_url?: string | null;
        published_at?: any | null;
        published_in?: string | null;
        summary?: string | null;
        table_count?: any | null;
        title?: string | null;
        updated_at?: any | null;
        version?: any | null;
        year?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneContentVariables = Exact<{
  _inc?: InputMaybe<ContentsIncInput>;
  _set?: InputMaybe<ContentsSetInput>;
  pk_columns: ContentsPkColumnsInput;
}>;

export type UpdateOneContentResponse = {
  __typename?: "mutation_root";
  update_contents_by_pk?: {
    __typename?: "contents";
    content_type: any;
    created_at?: any | null;
    hot_score?: any | null;
    id: any;
    rss_url?: string | null;
    title?: string | null;
    updated_at?: any | null;
    url: string;
    bookmarks: Array<{
      __typename?: "bookmarks";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      folder_id?: any | null;
      id: any;
      metadata?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    content_categories: Array<{
      __typename?: "content_categories";
      category_id: any;
      content_id: any;
      is_primary: boolean;
    }>;
    content_source_visits: Array<{
      __typename?: "content_source_visits";
      content_id: any;
      created_at?: any | null;
      id: any;
      user_id?: any | null;
    }>;
    content_statuses: Array<{
      __typename?: "content_statuses";
      content_id: any;
      content_status: any;
      created_at?: any | null;
      id: any;
      notes?: string | null;
    }>;
    content_tags: Array<{
      __typename?: "content_tags";
      content_id: any;
      tag_id: number;
    }>;
    news?: {
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    } | null;
    newsletter?: {
      __typename?: "newsletters";
      content_status: any;
      created_at?: any | null;
      end_date: any;
      frequency: string;
      generated_content?: string | null;
      id: any;
      start_date: any;
      title: string;
      updated_at?: any | null;
    } | null;
    research?: {
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
    } | null;
  } | null;
};

export type UpdateManyContentsManyVariables = Exact<{
  updates: Array<ContentsUpdates> | ContentsUpdates;
}>;

export type UpdateManyContentsManyResponse = {
  __typename?: "mutation_root";
  update_contents_many?: Array<{
    __typename?: "contents_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
      bookmarks: Array<{
        __typename?: "bookmarks";
        content_id: any;
        content_type: string;
        created_at?: any | null;
        folder_id?: any | null;
        id: any;
        metadata?: any | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      content_categories: Array<{
        __typename?: "content_categories";
        category_id: any;
        content_id: any;
        is_primary: boolean;
      }>;
      content_source_visits: Array<{
        __typename?: "content_source_visits";
        content_id: any;
        created_at?: any | null;
        id: any;
        user_id?: any | null;
      }>;
      content_statuses: Array<{
        __typename?: "content_statuses";
        content_id: any;
        content_status: any;
        created_at?: any | null;
        id: any;
        notes?: string | null;
      }>;
      content_tags: Array<{
        __typename?: "content_tags";
        content_id: any;
        tag_id: number;
      }>;
      news?: {
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      } | null;
      newsletter?: {
        __typename?: "newsletters";
        content_status: any;
        created_at?: any | null;
        end_date: any;
        frequency: string;
        generated_content?: string | null;
        id: any;
        start_date: any;
        title: string;
        updated_at?: any | null;
      } | null;
      research?: {
        __typename?: "research";
        abstract?: string | null;
        abstract_url: string;
        affiliations?: any | null;
        authors?: any | null;
        category?: string | null;
        comments?: string | null;
        content_status: any;
        created_at: any;
        doi_url?: string | null;
        figure_count?: any | null;
        has_embedding?: boolean | null;
        id: any;
        is_flagged: boolean;
        keywords?: string | null;
        month?: string | null;
        page_count?: any | null;
        pdf_url?: string | null;
        published_at?: any | null;
        published_in?: string | null;
        summary?: string | null;
        table_count?: any | null;
        title?: string | null;
        updated_at?: any | null;
        version?: any | null;
        year?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyCountryVariables = Exact<{
  _inc?: InputMaybe<CountriesIncInput>;
  _set?: InputMaybe<CountriesSetInput>;
  where: CountriesBoolExp;
}>;

export type UpdateManyCountryResponse = {
  __typename?: "mutation_root";
  update_countries?: {
    __typename?: "countries_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "countries";
      code: string;
      code_3?: string | null;
      id: number;
      name: string;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      cities: Array<{
        __typename?: "cities";
        country_id: number;
        id: number;
        name: string;
        state?: string | null;
      }>;
    }>;
  } | null;
};

export type UpdateOneCountryVariables = Exact<{
  _inc?: InputMaybe<CountriesIncInput>;
  _set?: InputMaybe<CountriesSetInput>;
  pk_columns: CountriesPkColumnsInput;
}>;

export type UpdateOneCountryResponse = {
  __typename?: "mutation_root";
  update_countries_by_pk?: {
    __typename?: "countries";
    code: string;
    code_3?: string | null;
    id: number;
    name: string;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    cities: Array<{
      __typename?: "cities";
      country_id: number;
      id: number;
      name: string;
      state?: string | null;
    }>;
  } | null;
};

export type UpdateManyCountriesManyVariables = Exact<{
  updates: Array<CountriesUpdates> | CountriesUpdates;
}>;

export type UpdateManyCountriesManyResponse = {
  __typename?: "mutation_root";
  update_countries_many?: Array<{
    __typename?: "countries_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "countries";
      code: string;
      code_3?: string | null;
      id: number;
      name: string;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      cities: Array<{
        __typename?: "cities";
        country_id: number;
        id: number;
        name: string;
        state?: string | null;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyCustomerPaymentVariables = Exact<{
  _append?: InputMaybe<CustomerPaymentsAppendInput>;
  _delete_at_path?: InputMaybe<CustomerPaymentsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerPaymentsDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerPaymentsDeleteKeyInput>;
  _inc?: InputMaybe<CustomerPaymentsIncInput>;
  _prepend?: InputMaybe<CustomerPaymentsPrependInput>;
  _set?: InputMaybe<CustomerPaymentsSetInput>;
  where: CustomerPaymentsBoolExp;
}>;

export type UpdateManyCustomerPaymentResponse = {
  __typename?: "mutation_root";
  update_customer_payments?: {
    __typename?: "customer_payments_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
      customer_refunds: Array<{
        __typename?: "customer_refunds";
        acquirer_data?: any | null;
        amount: any;
        batch_id?: string | null;
        created_at?: any | null;
        currency?: string | null;
        external_refund_id: string;
        id: number;
        notes?: any | null;
        payment_id: number;
        receipt?: string | null;
        speed_processed?: string | null;
        speed_requested?: string | null;
        status: string;
      }>;
      customer_subscription?: {
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      } | null;
      payment_provider: {
        __typename?: "payment_providers";
        created_at?: any | null;
        id: number;
        is_active?: boolean | null;
        name: string;
        updated_at?: any | null;
      };
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneCustomerPaymentVariables = Exact<{
  _append?: InputMaybe<CustomerPaymentsAppendInput>;
  _delete_at_path?: InputMaybe<CustomerPaymentsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerPaymentsDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerPaymentsDeleteKeyInput>;
  _inc?: InputMaybe<CustomerPaymentsIncInput>;
  _prepend?: InputMaybe<CustomerPaymentsPrependInput>;
  _set?: InputMaybe<CustomerPaymentsSetInput>;
  pk_columns: CustomerPaymentsPkColumnsInput;
}>;

export type UpdateOneCustomerPaymentResponse = {
  __typename?: "mutation_root";
  update_customer_payments_by_pk?: {
    __typename?: "customer_payments";
    acquirer_data?: any | null;
    amount: any;
    amount_refunded?: any | null;
    amount_transferred?: any | null;
    bank?: string | null;
    captured?: boolean | null;
    created_at?: any | null;
    currency: string;
    description?: string | null;
    error_code?: string | null;
    error_description?: string | null;
    error_reason?: string | null;
    error_source?: string | null;
    error_step?: string | null;
    external_order_id?: string | null;
    external_payment_id: string;
    fee?: any | null;
    id: number;
    international?: boolean | null;
    invoice_id?: string | null;
    method?: string | null;
    notes?: any | null;
    order_id?: string | null;
    payment_provider_id: number;
    refund_status?: string | null;
    status: string;
    subscription_id?: number | null;
    tax?: any | null;
    user_id: any;
    vpa?: string | null;
    wallet?: string | null;
    customer_refunds: Array<{
      __typename?: "customer_refunds";
      acquirer_data?: any | null;
      amount: any;
      batch_id?: string | null;
      created_at?: any | null;
      currency?: string | null;
      external_refund_id: string;
      id: number;
      notes?: any | null;
      payment_id: number;
      receipt?: string | null;
      speed_processed?: string | null;
      speed_requested?: string | null;
      status: string;
    }>;
    customer_subscription?: {
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    } | null;
    payment_provider: {
      __typename?: "payment_providers";
      created_at?: any | null;
      id: number;
      is_active?: boolean | null;
      name: string;
      updated_at?: any | null;
    };
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type UpdateManyCustomerPaymentsManyVariables = Exact<{
  updates: Array<CustomerPaymentsUpdates> | CustomerPaymentsUpdates;
}>;

export type UpdateManyCustomerPaymentsManyResponse = {
  __typename?: "mutation_root";
  update_customer_payments_many?: Array<{
    __typename?: "customer_payments_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
      customer_refunds: Array<{
        __typename?: "customer_refunds";
        acquirer_data?: any | null;
        amount: any;
        batch_id?: string | null;
        created_at?: any | null;
        currency?: string | null;
        external_refund_id: string;
        id: number;
        notes?: any | null;
        payment_id: number;
        receipt?: string | null;
        speed_processed?: string | null;
        speed_requested?: string | null;
        status: string;
      }>;
      customer_subscription?: {
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      } | null;
      payment_provider: {
        __typename?: "payment_providers";
        created_at?: any | null;
        id: number;
        is_active?: boolean | null;
        name: string;
        updated_at?: any | null;
      };
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyCustomerProcessedWebhookVariables = Exact<{
  _inc?: InputMaybe<CustomerProcessedWebhooksIncInput>;
  _set?: InputMaybe<CustomerProcessedWebhooksSetInput>;
  where: CustomerProcessedWebhooksBoolExp;
}>;

export type UpdateManyCustomerProcessedWebhookResponse = {
  __typename?: "mutation_root";
  update_customer_processed_webhooks?: {
    __typename?: "customer_processed_webhooks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_processed_webhooks";
      event_id: string;
      event_type: string;
      id: number;
      processed_at: any;
    }>;
  } | null;
};

export type UpdateOneCustomerProcessedWebhookVariables = Exact<{
  _inc?: InputMaybe<CustomerProcessedWebhooksIncInput>;
  _set?: InputMaybe<CustomerProcessedWebhooksSetInput>;
  pk_columns: CustomerProcessedWebhooksPkColumnsInput;
}>;

export type UpdateOneCustomerProcessedWebhookResponse = {
  __typename?: "mutation_root";
  update_customer_processed_webhooks_by_pk?: {
    __typename?: "customer_processed_webhooks";
    event_id: string;
    event_type: string;
    id: number;
    processed_at: any;
  } | null;
};

export type UpdateManyCustomerProcessedWebhooksManyVariables = Exact<{
  updates:
    | Array<CustomerProcessedWebhooksUpdates>
    | CustomerProcessedWebhooksUpdates;
}>;

export type UpdateManyCustomerProcessedWebhooksManyResponse = {
  __typename?: "mutation_root";
  update_customer_processed_webhooks_many?: Array<{
    __typename?: "customer_processed_webhooks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_processed_webhooks";
      event_id: string;
      event_type: string;
      id: number;
      processed_at: any;
    }>;
  } | null> | null;
};

export type UpdateManyCustomerRefundVariables = Exact<{
  _append?: InputMaybe<CustomerRefundsAppendInput>;
  _delete_at_path?: InputMaybe<CustomerRefundsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerRefundsDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerRefundsDeleteKeyInput>;
  _inc?: InputMaybe<CustomerRefundsIncInput>;
  _prepend?: InputMaybe<CustomerRefundsPrependInput>;
  _set?: InputMaybe<CustomerRefundsSetInput>;
  where: CustomerRefundsBoolExp;
}>;

export type UpdateManyCustomerRefundResponse = {
  __typename?: "mutation_root";
  update_customer_refunds?: {
    __typename?: "customer_refunds_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_refunds";
      acquirer_data?: any | null;
      amount: any;
      batch_id?: string | null;
      created_at?: any | null;
      currency?: string | null;
      external_refund_id: string;
      id: number;
      notes?: any | null;
      payment_id: number;
      receipt?: string | null;
      speed_processed?: string | null;
      speed_requested?: string | null;
      status: string;
      customer_payment: {
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneCustomerRefundVariables = Exact<{
  _append?: InputMaybe<CustomerRefundsAppendInput>;
  _delete_at_path?: InputMaybe<CustomerRefundsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerRefundsDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerRefundsDeleteKeyInput>;
  _inc?: InputMaybe<CustomerRefundsIncInput>;
  _prepend?: InputMaybe<CustomerRefundsPrependInput>;
  _set?: InputMaybe<CustomerRefundsSetInput>;
  pk_columns: CustomerRefundsPkColumnsInput;
}>;

export type UpdateOneCustomerRefundResponse = {
  __typename?: "mutation_root";
  update_customer_refunds_by_pk?: {
    __typename?: "customer_refunds";
    acquirer_data?: any | null;
    amount: any;
    batch_id?: string | null;
    created_at?: any | null;
    currency?: string | null;
    external_refund_id: string;
    id: number;
    notes?: any | null;
    payment_id: number;
    receipt?: string | null;
    speed_processed?: string | null;
    speed_requested?: string | null;
    status: string;
    customer_payment: {
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    };
  } | null;
};

export type UpdateManyCustomerRefundsManyVariables = Exact<{
  updates: Array<CustomerRefundsUpdates> | CustomerRefundsUpdates;
}>;

export type UpdateManyCustomerRefundsManyResponse = {
  __typename?: "mutation_root";
  update_customer_refunds_many?: Array<{
    __typename?: "customer_refunds_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_refunds";
      acquirer_data?: any | null;
      amount: any;
      batch_id?: string | null;
      created_at?: any | null;
      currency?: string | null;
      external_refund_id: string;
      id: number;
      notes?: any | null;
      payment_id: number;
      receipt?: string | null;
      speed_processed?: string | null;
      speed_requested?: string | null;
      status: string;
      customer_payment: {
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyCustomerSubscriptionPlanVariables = Exact<{
  _append?: InputMaybe<CustomerSubscriptionPlansAppendInput>;
  _delete_at_path?: InputMaybe<CustomerSubscriptionPlansDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerSubscriptionPlansDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerSubscriptionPlansDeleteKeyInput>;
  _inc?: InputMaybe<CustomerSubscriptionPlansIncInput>;
  _prepend?: InputMaybe<CustomerSubscriptionPlansPrependInput>;
  _set?: InputMaybe<CustomerSubscriptionPlansSetInput>;
  where: CustomerSubscriptionPlansBoolExp;
}>;

export type UpdateManyCustomerSubscriptionPlanResponse = {
  __typename?: "mutation_root";
  update_customer_subscription_plans?: {
    __typename?: "customer_subscription_plans_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_subscription_plans";
      annual_amount: any;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      external_plan_id?: string | null;
      features?: any | null;
      id: number;
      interval: number;
      interval_type: string;
      is_active?: boolean | null;
      monthly_amount: any;
      name: string;
      updated_at?: any | null;
      customer_subscriptions: Array<{
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      }>;
    }>;
  } | null;
};

export type UpdateOneCustomerSubscriptionPlanVariables = Exact<{
  _append?: InputMaybe<CustomerSubscriptionPlansAppendInput>;
  _delete_at_path?: InputMaybe<CustomerSubscriptionPlansDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerSubscriptionPlansDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerSubscriptionPlansDeleteKeyInput>;
  _inc?: InputMaybe<CustomerSubscriptionPlansIncInput>;
  _prepend?: InputMaybe<CustomerSubscriptionPlansPrependInput>;
  _set?: InputMaybe<CustomerSubscriptionPlansSetInput>;
  pk_columns: CustomerSubscriptionPlansPkColumnsInput;
}>;

export type UpdateOneCustomerSubscriptionPlanResponse = {
  __typename?: "mutation_root";
  update_customer_subscription_plans_by_pk?: {
    __typename?: "customer_subscription_plans";
    annual_amount: any;
    created_at?: any | null;
    currency: string;
    description?: string | null;
    external_plan_id?: string | null;
    features?: any | null;
    id: number;
    interval: number;
    interval_type: string;
    is_active?: boolean | null;
    monthly_amount: any;
    name: string;
    updated_at?: any | null;
    customer_subscriptions: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  } | null;
};

export type UpdateManyCustomerSubscriptionPlansManyVariables = Exact<{
  updates:
    | Array<CustomerSubscriptionPlansUpdates>
    | CustomerSubscriptionPlansUpdates;
}>;

export type UpdateManyCustomerSubscriptionPlansManyResponse = {
  __typename?: "mutation_root";
  update_customer_subscription_plans_many?: Array<{
    __typename?: "customer_subscription_plans_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_subscription_plans";
      annual_amount: any;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      external_plan_id?: string | null;
      features?: any | null;
      id: number;
      interval: number;
      interval_type: string;
      is_active?: boolean | null;
      monthly_amount: any;
      name: string;
      updated_at?: any | null;
      customer_subscriptions: Array<{
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyCustomerSubscriptionVariables = Exact<{
  _append?: InputMaybe<CustomerSubscriptionsAppendInput>;
  _delete_at_path?: InputMaybe<CustomerSubscriptionsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerSubscriptionsDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerSubscriptionsDeleteKeyInput>;
  _inc?: InputMaybe<CustomerSubscriptionsIncInput>;
  _prepend?: InputMaybe<CustomerSubscriptionsPrependInput>;
  _set?: InputMaybe<CustomerSubscriptionsSetInput>;
  where: CustomerSubscriptionsBoolExp;
}>;

export type UpdateManyCustomerSubscriptionResponse = {
  __typename?: "mutation_root";
  update_customer_subscriptions?: {
    __typename?: "customer_subscriptions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
      customer_payments: Array<{
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      }>;
      customer_subscription_plan: {
        __typename?: "customer_subscription_plans";
        annual_amount: any;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        external_plan_id?: string | null;
        features?: any | null;
        id: number;
        interval: number;
        interval_type: string;
        is_active?: boolean | null;
        monthly_amount: any;
        name: string;
        updated_at?: any | null;
      };
      payment_provider: {
        __typename?: "payment_providers";
        created_at?: any | null;
        id: number;
        is_active?: boolean | null;
        name: string;
        updated_at?: any | null;
      };
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneCustomerSubscriptionVariables = Exact<{
  _append?: InputMaybe<CustomerSubscriptionsAppendInput>;
  _delete_at_path?: InputMaybe<CustomerSubscriptionsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<CustomerSubscriptionsDeleteElemInput>;
  _delete_key?: InputMaybe<CustomerSubscriptionsDeleteKeyInput>;
  _inc?: InputMaybe<CustomerSubscriptionsIncInput>;
  _prepend?: InputMaybe<CustomerSubscriptionsPrependInput>;
  _set?: InputMaybe<CustomerSubscriptionsSetInput>;
  pk_columns: CustomerSubscriptionsPkColumnsInput;
}>;

export type UpdateOneCustomerSubscriptionResponse = {
  __typename?: "mutation_root";
  update_customer_subscriptions_by_pk?: {
    __typename?: "customer_subscriptions";
    auth_attempts?: number | null;
    cancel_at_period_end?: boolean | null;
    cancel_initiated_by?: string | null;
    change_scheduled_at?: any | null;
    charge_at?: any | null;
    created_at?: any | null;
    current_end: any;
    current_start: any;
    customer_notify?: boolean | null;
    end_at?: any | null;
    ended_at?: any | null;
    expire_by?: any | null;
    external_subscription_id: string;
    has_scheduled_changes?: boolean | null;
    id: number;
    notes?: any | null;
    offer_id?: string | null;
    paid_count?: number | null;
    pause_initiated_by?: string | null;
    payment_provider_id: number;
    plan_id: number;
    quantity?: number | null;
    remaining_count?: number | null;
    short_url?: string | null;
    source?: string | null;
    start_at?: any | null;
    status: string;
    total_count?: number | null;
    type?: number | null;
    updated_at?: any | null;
    user_id: any;
    customer_payments: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
    customer_subscription_plan: {
      __typename?: "customer_subscription_plans";
      annual_amount: any;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      external_plan_id?: string | null;
      features?: any | null;
      id: number;
      interval: number;
      interval_type: string;
      is_active?: boolean | null;
      monthly_amount: any;
      name: string;
      updated_at?: any | null;
    };
    payment_provider: {
      __typename?: "payment_providers";
      created_at?: any | null;
      id: number;
      is_active?: boolean | null;
      name: string;
      updated_at?: any | null;
    };
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type UpdateManyCustomerSubscriptionsManyVariables = Exact<{
  updates: Array<CustomerSubscriptionsUpdates> | CustomerSubscriptionsUpdates;
}>;

export type UpdateManyCustomerSubscriptionsManyResponse = {
  __typename?: "mutation_root";
  update_customer_subscriptions_many?: Array<{
    __typename?: "customer_subscriptions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
      customer_payments: Array<{
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      }>;
      customer_subscription_plan: {
        __typename?: "customer_subscription_plans";
        annual_amount: any;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        external_plan_id?: string | null;
        features?: any | null;
        id: number;
        interval: number;
        interval_type: string;
        is_active?: boolean | null;
        monthly_amount: any;
        name: string;
        updated_at?: any | null;
      };
      payment_provider: {
        __typename?: "payment_providers";
        created_at?: any | null;
        id: number;
        is_active?: boolean | null;
        name: string;
        updated_at?: any | null;
      };
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyEmbeddingReviewVariables = Exact<{
  _inc?: InputMaybe<EmbeddingReviewsIncInput>;
  _set?: InputMaybe<EmbeddingReviewsSetInput>;
  where: EmbeddingReviewsBoolExp;
}>;

export type UpdateManyEmbeddingReviewResponse = {
  __typename?: "mutation_root";
  update_embedding_reviews?: {
    __typename?: "embedding_reviews_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "embedding_reviews";
      agent_review?: boolean | null;
      created_at: any;
      human_review?: boolean | null;
      id: any;
      notes?: string | null;
      updated_at?: any | null;
      research_embeddings: Array<{
        __typename?: "research_embeddings";
        chunk: string;
        created_at?: any | null;
        embedding?: any | null;
        embedding_review_id?: any | null;
        id: number;
        is_flagged?: boolean | null;
        research_id: any;
        updated_at: any;
        url?: string | null;
      }>;
    }>;
  } | null;
};

export type UpdateOneEmbeddingReviewVariables = Exact<{
  _inc?: InputMaybe<EmbeddingReviewsIncInput>;
  _set?: InputMaybe<EmbeddingReviewsSetInput>;
  pk_columns: EmbeddingReviewsPkColumnsInput;
}>;

export type UpdateOneEmbeddingReviewResponse = {
  __typename?: "mutation_root";
  update_embedding_reviews_by_pk?: {
    __typename?: "embedding_reviews";
    agent_review?: boolean | null;
    created_at: any;
    human_review?: boolean | null;
    id: any;
    notes?: string | null;
    updated_at?: any | null;
    research_embeddings: Array<{
      __typename?: "research_embeddings";
      chunk: string;
      created_at?: any | null;
      embedding?: any | null;
      embedding_review_id?: any | null;
      id: number;
      is_flagged?: boolean | null;
      research_id: any;
      updated_at: any;
      url?: string | null;
    }>;
  } | null;
};

export type UpdateManyEmbeddingReviewsManyVariables = Exact<{
  updates: Array<EmbeddingReviewsUpdates> | EmbeddingReviewsUpdates;
}>;

export type UpdateManyEmbeddingReviewsManyResponse = {
  __typename?: "mutation_root";
  update_embedding_reviews_many?: Array<{
    __typename?: "embedding_reviews_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "embedding_reviews";
      agent_review?: boolean | null;
      created_at: any;
      human_review?: boolean | null;
      id: any;
      notes?: string | null;
      updated_at?: any | null;
      research_embeddings: Array<{
        __typename?: "research_embeddings";
        chunk: string;
        created_at?: any | null;
        embedding?: any | null;
        embedding_review_id?: any | null;
        id: number;
        is_flagged?: boolean | null;
        research_id: any;
        updated_at: any;
        url?: string | null;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyErrorLogVariables = Exact<{
  _append?: InputMaybe<ErrorLogsAppendInput>;
  _delete_at_path?: InputMaybe<ErrorLogsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<ErrorLogsDeleteElemInput>;
  _delete_key?: InputMaybe<ErrorLogsDeleteKeyInput>;
  _prepend?: InputMaybe<ErrorLogsPrependInput>;
  _set?: InputMaybe<ErrorLogsSetInput>;
  where: ErrorLogsBoolExp;
}>;

export type UpdateManyErrorLogResponse = {
  __typename?: "mutation_root";
  update_error_logs?: {
    __typename?: "error_logs_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "error_logs";
      context?: any | null;
      correlation_id?: any | null;
      created_at?: any | null;
      domain?: string | null;
      environment: string;
      error_hash?: string | null;
      error_pattern?: string | null;
      error_type: any;
      frequency_data?: any | null;
      github_repo?: string | null;
      id: any;
      is_new_pattern?: boolean | null;
      message: string;
      metadata?: any | null;
      related_errors?: any | null;
      request_id?: any | null;
      service_name: string;
      severity: any;
      stack_trace?: string | null;
      user_id?: any | null;
    }>;
  } | null;
};

export type UpdateOneErrorLogVariables = Exact<{
  _append?: InputMaybe<ErrorLogsAppendInput>;
  _delete_at_path?: InputMaybe<ErrorLogsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<ErrorLogsDeleteElemInput>;
  _delete_key?: InputMaybe<ErrorLogsDeleteKeyInput>;
  _prepend?: InputMaybe<ErrorLogsPrependInput>;
  _set?: InputMaybe<ErrorLogsSetInput>;
  pk_columns: ErrorLogsPkColumnsInput;
}>;

export type UpdateOneErrorLogResponse = {
  __typename?: "mutation_root";
  update_error_logs_by_pk?: {
    __typename?: "error_logs";
    context?: any | null;
    correlation_id?: any | null;
    created_at?: any | null;
    domain?: string | null;
    environment: string;
    error_hash?: string | null;
    error_pattern?: string | null;
    error_type: any;
    frequency_data?: any | null;
    github_repo?: string | null;
    id: any;
    is_new_pattern?: boolean | null;
    message: string;
    metadata?: any | null;
    related_errors?: any | null;
    request_id?: any | null;
    service_name: string;
    severity: any;
    stack_trace?: string | null;
    user_id?: any | null;
  } | null;
};

export type UpdateManyErrorLogsManyVariables = Exact<{
  updates: Array<ErrorLogsUpdates> | ErrorLogsUpdates;
}>;

export type UpdateManyErrorLogsManyResponse = {
  __typename?: "mutation_root";
  update_error_logs_many?: Array<{
    __typename?: "error_logs_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "error_logs";
      context?: any | null;
      correlation_id?: any | null;
      created_at?: any | null;
      domain?: string | null;
      environment: string;
      error_hash?: string | null;
      error_pattern?: string | null;
      error_type: any;
      frequency_data?: any | null;
      github_repo?: string | null;
      id: any;
      is_new_pattern?: boolean | null;
      message: string;
      metadata?: any | null;
      related_errors?: any | null;
      request_id?: any | null;
      service_name: string;
      severity: any;
      stack_trace?: string | null;
      user_id?: any | null;
    }>;
  } | null> | null;
};

export type UpdateManyFeatureRequestVariables = Exact<{
  _inc?: InputMaybe<FeatureRequestsIncInput>;
  _set?: InputMaybe<FeatureRequestsSetInput>;
  where: FeatureRequestsBoolExp;
}>;

export type UpdateManyFeatureRequestResponse = {
  __typename?: "mutation_root";
  update_feature_requests?: {
    __typename?: "feature_requests_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feature_requests";
      created_at?: any | null;
      description?: string | null;
      downvotes?: number | null;
      engagement_score?: number | null;
      id: any;
      priority_score?: number | null;
      status: string;
      title: string;
      updated_at?: any | null;
      upvotes?: number | null;
      feature_votes: Array<{
        __typename?: "feature_votes";
        created_at?: any | null;
        feature_id: any;
        feedback?: string | null;
        id: any;
        updated_at?: any | null;
        user_id: any;
        vote_type: any;
      }>;
    }>;
  } | null;
};

export type UpdateOneFeatureRequestVariables = Exact<{
  _inc?: InputMaybe<FeatureRequestsIncInput>;
  _set?: InputMaybe<FeatureRequestsSetInput>;
  pk_columns: FeatureRequestsPkColumnsInput;
}>;

export type UpdateOneFeatureRequestResponse = {
  __typename?: "mutation_root";
  update_feature_requests_by_pk?: {
    __typename?: "feature_requests";
    created_at?: any | null;
    description?: string | null;
    downvotes?: number | null;
    engagement_score?: number | null;
    id: any;
    priority_score?: number | null;
    status: string;
    title: string;
    updated_at?: any | null;
    upvotes?: number | null;
    feature_votes: Array<{
      __typename?: "feature_votes";
      created_at?: any | null;
      feature_id: any;
      feedback?: string | null;
      id: any;
      updated_at?: any | null;
      user_id: any;
      vote_type: any;
    }>;
  } | null;
};

export type UpdateManyFeatureRequestsManyVariables = Exact<{
  updates: Array<FeatureRequestsUpdates> | FeatureRequestsUpdates;
}>;

export type UpdateManyFeatureRequestsManyResponse = {
  __typename?: "mutation_root";
  update_feature_requests_many?: Array<{
    __typename?: "feature_requests_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feature_requests";
      created_at?: any | null;
      description?: string | null;
      downvotes?: number | null;
      engagement_score?: number | null;
      id: any;
      priority_score?: number | null;
      status: string;
      title: string;
      updated_at?: any | null;
      upvotes?: number | null;
      feature_votes: Array<{
        __typename?: "feature_votes";
        created_at?: any | null;
        feature_id: any;
        feedback?: string | null;
        id: any;
        updated_at?: any | null;
        user_id: any;
        vote_type: any;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyFeatureVoteVariables = Exact<{
  _inc?: InputMaybe<FeatureVotesIncInput>;
  _set?: InputMaybe<FeatureVotesSetInput>;
  where: FeatureVotesBoolExp;
}>;

export type UpdateManyFeatureVoteResponse = {
  __typename?: "mutation_root";
  update_feature_votes?: {
    __typename?: "feature_votes_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feature_votes";
      created_at?: any | null;
      feature_id: any;
      feedback?: string | null;
      id: any;
      updated_at?: any | null;
      user_id: any;
      vote_type: any;
      feature_request: {
        __typename?: "feature_requests";
        created_at?: any | null;
        description?: string | null;
        downvotes?: number | null;
        engagement_score?: number | null;
        id: any;
        priority_score?: number | null;
        status: string;
        title: string;
        updated_at?: any | null;
        upvotes?: number | null;
      };
    }>;
  } | null;
};

export type UpdateOneFeatureVoteVariables = Exact<{
  _inc?: InputMaybe<FeatureVotesIncInput>;
  _set?: InputMaybe<FeatureVotesSetInput>;
  pk_columns: FeatureVotesPkColumnsInput;
}>;

export type UpdateOneFeatureVoteResponse = {
  __typename?: "mutation_root";
  update_feature_votes_by_pk?: {
    __typename?: "feature_votes";
    created_at?: any | null;
    feature_id: any;
    feedback?: string | null;
    id: any;
    updated_at?: any | null;
    user_id: any;
    vote_type: any;
    feature_request: {
      __typename?: "feature_requests";
      created_at?: any | null;
      description?: string | null;
      downvotes?: number | null;
      engagement_score?: number | null;
      id: any;
      priority_score?: number | null;
      status: string;
      title: string;
      updated_at?: any | null;
      upvotes?: number | null;
    };
  } | null;
};

export type UpdateManyFeatureVotesManyVariables = Exact<{
  updates: Array<FeatureVotesUpdates> | FeatureVotesUpdates;
}>;

export type UpdateManyFeatureVotesManyResponse = {
  __typename?: "mutation_root";
  update_feature_votes_many?: Array<{
    __typename?: "feature_votes_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feature_votes";
      created_at?: any | null;
      feature_id: any;
      feedback?: string | null;
      id: any;
      updated_at?: any | null;
      user_id: any;
      vote_type: any;
      feature_request: {
        __typename?: "feature_requests";
        created_at?: any | null;
        description?: string | null;
        downvotes?: number | null;
        engagement_score?: number | null;
        id: any;
        priority_score?: number | null;
        status: string;
        title: string;
        updated_at?: any | null;
        upvotes?: number | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyFeedCategoryVariables = Exact<{
  _inc?: InputMaybe<FeedCategoriesIncInput>;
  _set?: InputMaybe<FeedCategoriesSetInput>;
  where: FeedCategoriesBoolExp;
}>;

export type UpdateManyFeedCategoryResponse = {
  __typename?: "mutation_root";
  update_feed_categories?: {
    __typename?: "feed_categories_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feed_categories";
      category_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
      category?: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      } | null;
      feed?: {
        __typename?: "feeds";
        created_at: any;
        id: any;
        name?: string | null;
        user_id?: any | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneFeedCategoryVariables = Exact<{
  _inc?: InputMaybe<FeedCategoriesIncInput>;
  _set?: InputMaybe<FeedCategoriesSetInput>;
  pk_columns: FeedCategoriesPkColumnsInput;
}>;

export type UpdateOneFeedCategoryResponse = {
  __typename?: "mutation_root";
  update_feed_categories_by_pk?: {
    __typename?: "feed_categories";
    category_id?: any | null;
    created_at: any;
    feed_id?: any | null;
    id: any;
    category?: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    } | null;
    feed?: {
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    } | null;
  } | null;
};

export type UpdateManyFeedCategoriesManyVariables = Exact<{
  updates: Array<FeedCategoriesUpdates> | FeedCategoriesUpdates;
}>;

export type UpdateManyFeedCategoriesManyResponse = {
  __typename?: "mutation_root";
  update_feed_categories_many?: Array<{
    __typename?: "feed_categories_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feed_categories";
      category_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
      category?: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      } | null;
      feed?: {
        __typename?: "feeds";
        created_at: any;
        id: any;
        name?: string | null;
        user_id?: any | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyFeedSourceVariables = Exact<{
  _inc?: InputMaybe<FeedSourcesIncInput>;
  _set?: InputMaybe<FeedSourcesSetInput>;
  where: FeedSourcesBoolExp;
}>;

export type UpdateManyFeedSourceResponse = {
  __typename?: "mutation_root";
  update_feed_sources?: {
    __typename?: "feed_sources_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feed_sources";
      content_source_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
      content_source?: {
        __typename?: "content_sources";
        company_id?: any | null;
        content_type: any;
        created_at?: any | null;
        expected_count?: any | null;
        failed_count?: any | null;
        has_failed?: boolean | null;
        hash?: any | null;
        id: any;
        priority: any;
        refreshed_at?: any | null;
        rss_urls?: Array<string> | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        updated_at?: any | null;
        url: string;
      } | null;
      feed?: {
        __typename?: "feeds";
        created_at: any;
        id: any;
        name?: string | null;
        user_id?: any | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneFeedSourceVariables = Exact<{
  _inc?: InputMaybe<FeedSourcesIncInput>;
  _set?: InputMaybe<FeedSourcesSetInput>;
  pk_columns: FeedSourcesPkColumnsInput;
}>;

export type UpdateOneFeedSourceResponse = {
  __typename?: "mutation_root";
  update_feed_sources_by_pk?: {
    __typename?: "feed_sources";
    content_source_id?: any | null;
    created_at: any;
    feed_id?: any | null;
    id: any;
    content_source?: {
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    } | null;
    feed?: {
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    } | null;
  } | null;
};

export type UpdateManyFeedSourcesManyVariables = Exact<{
  updates: Array<FeedSourcesUpdates> | FeedSourcesUpdates;
}>;

export type UpdateManyFeedSourcesManyResponse = {
  __typename?: "mutation_root";
  update_feed_sources_many?: Array<{
    __typename?: "feed_sources_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feed_sources";
      content_source_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
      content_source?: {
        __typename?: "content_sources";
        company_id?: any | null;
        content_type: any;
        created_at?: any | null;
        expected_count?: any | null;
        failed_count?: any | null;
        has_failed?: boolean | null;
        hash?: any | null;
        id: any;
        priority: any;
        refreshed_at?: any | null;
        rss_urls?: Array<string> | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        updated_at?: any | null;
        url: string;
      } | null;
      feed?: {
        __typename?: "feeds";
        created_at: any;
        id: any;
        name?: string | null;
        user_id?: any | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyFeedbackVariables = Exact<{
  _inc?: InputMaybe<FeedbacksIncInput>;
  _set?: InputMaybe<FeedbacksSetInput>;
  where: FeedbacksBoolExp;
}>;

export type UpdateManyFeedbackResponse = {
  __typename?: "mutation_root";
  update_feedbacks?: {
    __typename?: "feedbacks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feedbacks";
      created_at: any;
      device_info?: string | null;
      feedback_status?: any | null;
      feedback_type?: any | null;
      id: number;
      message: string;
      page_identifier: string;
      rating?: number | null;
      resolution_comment?: string | null;
      updated_at: any;
      user_id?: any | null;
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneFeedbackVariables = Exact<{
  _inc?: InputMaybe<FeedbacksIncInput>;
  _set?: InputMaybe<FeedbacksSetInput>;
  pk_columns: FeedbacksPkColumnsInput;
}>;

export type UpdateOneFeedbackResponse = {
  __typename?: "mutation_root";
  update_feedbacks_by_pk?: {
    __typename?: "feedbacks";
    created_at: any;
    device_info?: string | null;
    feedback_status?: any | null;
    feedback_type?: any | null;
    id: number;
    message: string;
    page_identifier: string;
    rating?: number | null;
    resolution_comment?: string | null;
    updated_at: any;
    user_id?: any | null;
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type UpdateManyFeedbacksManyVariables = Exact<{
  updates: Array<FeedbacksUpdates> | FeedbacksUpdates;
}>;

export type UpdateManyFeedbacksManyResponse = {
  __typename?: "mutation_root";
  update_feedbacks_many?: Array<{
    __typename?: "feedbacks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feedbacks";
      created_at: any;
      device_info?: string | null;
      feedback_status?: any | null;
      feedback_type?: any | null;
      id: number;
      message: string;
      page_identifier: string;
      rating?: number | null;
      resolution_comment?: string | null;
      updated_at: any;
      user_id?: any | null;
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyFeedVariables = Exact<{
  _set?: InputMaybe<FeedsSetInput>;
  where: FeedsBoolExp;
}>;

export type UpdateManyFeedResponse = {
  __typename?: "mutation_root";
  update_feeds?: {
    __typename?: "feeds_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
      feed_categories: Array<{
        __typename?: "feed_categories";
        category_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      feed_sources: Array<{
        __typename?: "feed_sources";
        content_source_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneFeedVariables = Exact<{
  _set?: InputMaybe<FeedsSetInput>;
  pk_columns: FeedsPkColumnsInput;
}>;

export type UpdateOneFeedResponse = {
  __typename?: "mutation_root";
  update_feeds_by_pk?: {
    __typename?: "feeds";
    created_at: any;
    id: any;
    name?: string | null;
    user_id?: any | null;
    feed_categories: Array<{
      __typename?: "feed_categories";
      category_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    feed_sources: Array<{
      __typename?: "feed_sources";
      content_source_id?: any | null;
      created_at: any;
      feed_id?: any | null;
      id: any;
    }>;
    user_profile?: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    } | null;
  } | null;
};

export type UpdateManyFeedsManyVariables = Exact<{
  updates: Array<FeedsUpdates> | FeedsUpdates;
}>;

export type UpdateManyFeedsManyResponse = {
  __typename?: "mutation_root";
  update_feeds_many?: Array<{
    __typename?: "feeds_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
      feed_categories: Array<{
        __typename?: "feed_categories";
        category_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      feed_sources: Array<{
        __typename?: "feed_sources";
        content_source_id?: any | null;
        created_at: any;
        feed_id?: any | null;
        id: any;
      }>;
      user_profile?: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyFollowVariables = Exact<{
  _set?: InputMaybe<FollowsSetInput>;
  where: FollowsBoolExp;
}>;

export type UpdateManyFollowResponse = {
  __typename?: "mutation_root";
  update_follows?: {
    __typename?: "follows_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "follows";
      created_at?: any | null;
      followed_entity: any;
      followed_id: any;
      id: any;
      user_id: any;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneFollowVariables = Exact<{
  _set?: InputMaybe<FollowsSetInput>;
  pk_columns: FollowsPkColumnsInput;
}>;

export type UpdateOneFollowResponse = {
  __typename?: "mutation_root";
  update_follows_by_pk?: {
    __typename?: "follows";
    created_at?: any | null;
    followed_entity: any;
    followed_id: any;
    id: any;
    user_id: any;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type UpdateManyFollowsManyVariables = Exact<{
  updates: Array<FollowsUpdates> | FollowsUpdates;
}>;

export type UpdateManyFollowsManyResponse = {
  __typename?: "mutation_root";
  update_follows_many?: Array<{
    __typename?: "follows_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "follows";
      created_at?: any | null;
      followed_entity: any;
      followed_id: any;
      id: any;
      user_id: any;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyMetricDefinitionVariables = Exact<{
  _inc?: InputMaybe<MetricDefinitionsIncInput>;
  _set?: InputMaybe<MetricDefinitionsSetInput>;
  where: MetricDefinitionsBoolExp;
}>;

export type UpdateManyMetricDefinitionResponse = {
  __typename?: "mutation_root";
  update_metric_definitions?: {
    __typename?: "metric_definitions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "metric_definitions";
      category?: string | null;
      description?: string | null;
      id: number;
      is_dimensional?: boolean | null;
      name: string;
      type: string;
      unit?: string | null;
      company_metrics: Array<{
        __typename?: "company_metrics";
        company_id: any;
        crawl_id: any;
        id: any;
        metric_id?: number | null;
        timestamp: any;
        value: any;
      }>;
      spider_metrics: Array<{
        __typename?: "spider_metrics";
        crawl_id: any;
        id: any;
        metric_id?: number | null;
        timestamp: any;
        value: any;
      }>;
    }>;
  } | null;
};

export type UpdateOneMetricDefinitionVariables = Exact<{
  _inc?: InputMaybe<MetricDefinitionsIncInput>;
  _set?: InputMaybe<MetricDefinitionsSetInput>;
  pk_columns: MetricDefinitionsPkColumnsInput;
}>;

export type UpdateOneMetricDefinitionResponse = {
  __typename?: "mutation_root";
  update_metric_definitions_by_pk?: {
    __typename?: "metric_definitions";
    category?: string | null;
    description?: string | null;
    id: number;
    is_dimensional?: boolean | null;
    name: string;
    type: string;
    unit?: string | null;
    company_metrics: Array<{
      __typename?: "company_metrics";
      company_id: any;
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
    }>;
    spider_metrics: Array<{
      __typename?: "spider_metrics";
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
    }>;
  } | null;
};

export type UpdateManyMetricDefinitionsManyVariables = Exact<{
  updates: Array<MetricDefinitionsUpdates> | MetricDefinitionsUpdates;
}>;

export type UpdateManyMetricDefinitionsManyResponse = {
  __typename?: "mutation_root";
  update_metric_definitions_many?: Array<{
    __typename?: "metric_definitions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "metric_definitions";
      category?: string | null;
      description?: string | null;
      id: number;
      is_dimensional?: boolean | null;
      name: string;
      type: string;
      unit?: string | null;
      company_metrics: Array<{
        __typename?: "company_metrics";
        company_id: any;
        crawl_id: any;
        id: any;
        metric_id?: number | null;
        timestamp: any;
        value: any;
      }>;
      spider_metrics: Array<{
        __typename?: "spider_metrics";
        crawl_id: any;
        id: any;
        metric_id?: number | null;
        timestamp: any;
        value: any;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyNewsVariables = Exact<{
  _append?: InputMaybe<NewsAppendInput>;
  _delete_at_path?: InputMaybe<NewsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<NewsDeleteElemInput>;
  _delete_key?: InputMaybe<NewsDeleteKeyInput>;
  _inc?: InputMaybe<NewsIncInput>;
  _prepend?: InputMaybe<NewsPrependInput>;
  _set?: InputMaybe<NewsSetInput>;
  where: NewsBoolExp;
}>;

export type UpdateManyNewsResponse = {
  __typename?: "mutation_root";
  update_news?: {
    __typename?: "news_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
      category?: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      } | null;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      content_source?: {
        __typename?: "content_sources";
        company_id?: any | null;
        content_type: any;
        created_at?: any | null;
        expected_count?: any | null;
        failed_count?: any | null;
        has_failed?: boolean | null;
        hash?: any | null;
        id: any;
        priority: any;
        refreshed_at?: any | null;
        rss_urls?: Array<string> | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        updated_at?: any | null;
        url: string;
      } | null;
      news_summaries: Array<{
        __typename?: "news_summaries";
        complexity_level?: any | null;
        created_at?: any | null;
        embedding?: any | null;
        id: any;
        is_current?: boolean | null;
        news_id: any;
        summary?: string | null;
        updated_at?: any | null;
        version: number;
      }>;
    }>;
  } | null;
};

export type UpdateOneNewsVariables = Exact<{
  _append?: InputMaybe<NewsAppendInput>;
  _delete_at_path?: InputMaybe<NewsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<NewsDeleteElemInput>;
  _delete_key?: InputMaybe<NewsDeleteKeyInput>;
  _inc?: InputMaybe<NewsIncInput>;
  _prepend?: InputMaybe<NewsPrependInput>;
  _set?: InputMaybe<NewsSetInput>;
  pk_columns: NewsPkColumnsInput;
}>;

export type UpdateOneNewsResponse = {
  __typename?: "mutation_root";
  update_news_by_pk?: {
    __typename?: "news";
    author?: string | null;
    body?: string | null;
    category_id?: any | null;
    company_id?: any | null;
    content_source_id?: any | null;
    content_status: any;
    created_at: any;
    description?: string | null;
    failed_count?: any | null;
    featured_image?: string | null;
    has_summary: boolean;
    hash?: any | null;
    id: any;
    keywords?: any | null;
    published_at?: any | null;
    scrape_frequency: any;
    scraped_at?: any | null;
    title?: string | null;
    updated_at: any;
    url: string;
    category?: {
      __typename?: "categories";
      body?: string | null;
      created_at: any;
      document_id?: string | null;
      id: any;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    } | null;
    company?: {
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    } | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    content_source?: {
      __typename?: "content_sources";
      company_id?: any | null;
      content_type: any;
      created_at?: any | null;
      expected_count?: any | null;
      failed_count?: any | null;
      has_failed?: boolean | null;
      hash?: any | null;
      id: any;
      priority: any;
      refreshed_at?: any | null;
      rss_urls?: Array<string> | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      updated_at?: any | null;
      url: string;
    } | null;
    news_summaries: Array<{
      __typename?: "news_summaries";
      complexity_level?: any | null;
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      is_current?: boolean | null;
      news_id: any;
      summary?: string | null;
      updated_at?: any | null;
      version: number;
    }>;
  } | null;
};

export type UpdateManyNewsManyVariables = Exact<{
  updates: Array<NewsUpdates> | NewsUpdates;
}>;

export type UpdateManyNewsManyResponse = {
  __typename?: "mutation_root";
  update_news_many?: Array<{
    __typename?: "news_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
      category?: {
        __typename?: "categories";
        body?: string | null;
        created_at: any;
        document_id?: string | null;
        id: any;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      } | null;
      company?: {
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      } | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      content_source?: {
        __typename?: "content_sources";
        company_id?: any | null;
        content_type: any;
        created_at?: any | null;
        expected_count?: any | null;
        failed_count?: any | null;
        has_failed?: boolean | null;
        hash?: any | null;
        id: any;
        priority: any;
        refreshed_at?: any | null;
        rss_urls?: Array<string> | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        updated_at?: any | null;
        url: string;
      } | null;
      news_summaries: Array<{
        __typename?: "news_summaries";
        complexity_level?: any | null;
        created_at?: any | null;
        embedding?: any | null;
        id: any;
        is_current?: boolean | null;
        news_id: any;
        summary?: string | null;
        updated_at?: any | null;
        version: number;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyNewsSummaryVariables = Exact<{
  _inc?: InputMaybe<NewsSummariesIncInput>;
  _set?: InputMaybe<NewsSummariesSetInput>;
  where: NewsSummariesBoolExp;
}>;

export type UpdateManyNewsSummaryResponse = {
  __typename?: "mutation_root";
  update_news_summaries?: {
    __typename?: "news_summaries_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "news_summaries";
      complexity_level?: any | null;
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      is_current?: boolean | null;
      news_id: any;
      summary?: string | null;
      updated_at?: any | null;
      version: number;
      news: {
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      };
    }>;
  } | null;
};

export type UpdateOneNewsSummaryVariables = Exact<{
  _inc?: InputMaybe<NewsSummariesIncInput>;
  _set?: InputMaybe<NewsSummariesSetInput>;
  pk_columns: NewsSummariesPkColumnsInput;
}>;

export type UpdateOneNewsSummaryResponse = {
  __typename?: "mutation_root";
  update_news_summaries_by_pk?: {
    __typename?: "news_summaries";
    complexity_level?: any | null;
    created_at?: any | null;
    embedding?: any | null;
    id: any;
    is_current?: boolean | null;
    news_id: any;
    summary?: string | null;
    updated_at?: any | null;
    version: number;
    news: {
      __typename?: "news";
      author?: string | null;
      body?: string | null;
      category_id?: any | null;
      company_id?: any | null;
      content_source_id?: any | null;
      content_status: any;
      created_at: any;
      description?: string | null;
      failed_count?: any | null;
      featured_image?: string | null;
      has_summary: boolean;
      hash?: any | null;
      id: any;
      keywords?: any | null;
      published_at?: any | null;
      scrape_frequency: any;
      scraped_at?: any | null;
      title?: string | null;
      updated_at: any;
      url: string;
    };
  } | null;
};

export type UpdateManyNewsSummariesManyVariables = Exact<{
  updates: Array<NewsSummariesUpdates> | NewsSummariesUpdates;
}>;

export type UpdateManyNewsSummariesManyResponse = {
  __typename?: "mutation_root";
  update_news_summaries_many?: Array<{
    __typename?: "news_summaries_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "news_summaries";
      complexity_level?: any | null;
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      is_current?: boolean | null;
      news_id: any;
      summary?: string | null;
      updated_at?: any | null;
      version: number;
      news: {
        __typename?: "news";
        author?: string | null;
        body?: string | null;
        category_id?: any | null;
        company_id?: any | null;
        content_source_id?: any | null;
        content_status: any;
        created_at: any;
        description?: string | null;
        failed_count?: any | null;
        featured_image?: string | null;
        has_summary: boolean;
        hash?: any | null;
        id: any;
        keywords?: any | null;
        published_at?: any | null;
        scrape_frequency: any;
        scraped_at?: any | null;
        title?: string | null;
        updated_at: any;
        url: string;
      };
    }>;
  } | null> | null;
};

export type UpdateManyNewsTagVariables = Exact<{
  _inc?: InputMaybe<NewsTagsIncInput>;
  _set?: InputMaybe<NewsTagsSetInput>;
  where: NewsTagsBoolExp;
}>;

export type UpdateManyNewsTagResponse = {
  __typename?: "mutation_root";
  update_news_tags?: {
    __typename?: "news_tags_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "news_tags";
      id: number;
      news_id?: any | null;
      tag_id: number;
      tag: {
        __typename?: "tags";
        body?: string | null;
        created_at?: any | null;
        document_id?: string | null;
        id: number;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      };
    }>;
  } | null;
};

export type UpdateOneNewsTagVariables = Exact<{
  _inc?: InputMaybe<NewsTagsIncInput>;
  _set?: InputMaybe<NewsTagsSetInput>;
  pk_columns: NewsTagsPkColumnsInput;
}>;

export type UpdateOneNewsTagResponse = {
  __typename?: "mutation_root";
  update_news_tags_by_pk?: {
    __typename?: "news_tags";
    id: number;
    news_id?: any | null;
    tag_id: number;
    tag: {
      __typename?: "tags";
      body?: string | null;
      created_at?: any | null;
      document_id?: string | null;
      id: number;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
    };
  } | null;
};

export type UpdateManyNewsTagsManyVariables = Exact<{
  updates: Array<NewsTagsUpdates> | NewsTagsUpdates;
}>;

export type UpdateManyNewsTagsManyResponse = {
  __typename?: "mutation_root";
  update_news_tags_many?: Array<{
    __typename?: "news_tags_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "news_tags";
      id: number;
      news_id?: any | null;
      tag_id: number;
      tag: {
        __typename?: "tags";
        body?: string | null;
        created_at?: any | null;
        document_id?: string | null;
        id: number;
        locale?: string | null;
        name: string;
        published_at?: string | null;
        updated_at?: any | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyNewsletterVariables = Exact<{
  _set?: InputMaybe<NewslettersSetInput>;
  where: NewslettersBoolExp;
}>;

export type UpdateManyNewsletterResponse = {
  __typename?: "mutation_root";
  update_newsletters?: {
    __typename?: "newsletters_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "newsletters";
      content_status: any;
      created_at?: any | null;
      end_date: any;
      frequency: string;
      generated_content?: string | null;
      id: any;
      start_date: any;
      title: string;
      updated_at?: any | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null;
};

export type UpdateOneNewsletterVariables = Exact<{
  _set?: InputMaybe<NewslettersSetInput>;
  pk_columns: NewslettersPkColumnsInput;
}>;

export type UpdateOneNewsletterResponse = {
  __typename?: "mutation_root";
  update_newsletters_by_pk?: {
    __typename?: "newsletters";
    content_status: any;
    created_at?: any | null;
    end_date: any;
    frequency: string;
    generated_content?: string | null;
    id: any;
    start_date: any;
    title: string;
    updated_at?: any | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
  } | null;
};

export type UpdateManyNewslettersManyVariables = Exact<{
  updates: Array<NewslettersUpdates> | NewslettersUpdates;
}>;

export type UpdateManyNewslettersManyResponse = {
  __typename?: "mutation_root";
  update_newsletters_many?: Array<{
    __typename?: "newsletters_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "newsletters";
      content_status: any;
      created_at?: any | null;
      end_date: any;
      frequency: string;
      generated_content?: string | null;
      id: any;
      start_date: any;
      title: string;
      updated_at?: any | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
    }>;
  } | null> | null;
};

export type UpdateManyPaymentProviderVariables = Exact<{
  _inc?: InputMaybe<PaymentProvidersIncInput>;
  _set?: InputMaybe<PaymentProvidersSetInput>;
  where: PaymentProvidersBoolExp;
}>;

export type UpdateManyPaymentProviderResponse = {
  __typename?: "mutation_root";
  update_payment_providers?: {
    __typename?: "payment_providers_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "payment_providers";
      created_at?: any | null;
      id: number;
      is_active?: boolean | null;
      name: string;
      updated_at?: any | null;
      customer_payments: Array<{
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      }>;
      customer_subscriptions: Array<{
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      }>;
    }>;
  } | null;
};

export type UpdateOnePaymentProviderVariables = Exact<{
  _inc?: InputMaybe<PaymentProvidersIncInput>;
  _set?: InputMaybe<PaymentProvidersSetInput>;
  pk_columns: PaymentProvidersPkColumnsInput;
}>;

export type UpdateOnePaymentProviderResponse = {
  __typename?: "mutation_root";
  update_payment_providers_by_pk?: {
    __typename?: "payment_providers";
    created_at?: any | null;
    id: number;
    is_active?: boolean | null;
    name: string;
    updated_at?: any | null;
    customer_payments: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
    customer_subscriptions: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
  } | null;
};

export type UpdateManyPaymentProvidersManyVariables = Exact<{
  updates: Array<PaymentProvidersUpdates> | PaymentProvidersUpdates;
}>;

export type UpdateManyPaymentProvidersManyResponse = {
  __typename?: "mutation_root";
  update_payment_providers_many?: Array<{
    __typename?: "payment_providers_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "payment_providers";
      created_at?: any | null;
      id: number;
      is_active?: boolean | null;
      name: string;
      updated_at?: any | null;
      customer_payments: Array<{
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      }>;
      customer_subscriptions: Array<{
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyPlanPermissionVariables = Exact<{
  _inc?: InputMaybe<PlanPermissionsIncInput>;
  _set?: InputMaybe<PlanPermissionsSetInput>;
  where: PlanPermissionsBoolExp;
}>;

export type UpdateManyPlanPermissionResponse = {
  __typename?: "mutation_root";
  update_plan_permissions?: {
    __typename?: "plan_permissions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "plan_permissions";
      feature: string;
      id: number;
      plan: any;
    }>;
  } | null;
};

export type UpdateOnePlanPermissionVariables = Exact<{
  _inc?: InputMaybe<PlanPermissionsIncInput>;
  _set?: InputMaybe<PlanPermissionsSetInput>;
  pk_columns: PlanPermissionsPkColumnsInput;
}>;

export type UpdateOnePlanPermissionResponse = {
  __typename?: "mutation_root";
  update_plan_permissions_by_pk?: {
    __typename?: "plan_permissions";
    feature: string;
    id: number;
    plan: any;
  } | null;
};

export type UpdateManyPlanPermissionsManyVariables = Exact<{
  updates: Array<PlanPermissionsUpdates> | PlanPermissionsUpdates;
}>;

export type UpdateManyPlanPermissionsManyResponse = {
  __typename?: "mutation_root";
  update_plan_permissions_many?: Array<{
    __typename?: "plan_permissions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "plan_permissions";
      feature: string;
      id: number;
      plan: any;
    }>;
  } | null> | null;
};

export type UpdateManyRecentErrorVariables = Exact<{
  _append?: InputMaybe<RecentErrorsAppendInput>;
  _delete_at_path?: InputMaybe<RecentErrorsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<RecentErrorsDeleteElemInput>;
  _delete_key?: InputMaybe<RecentErrorsDeleteKeyInput>;
  _prepend?: InputMaybe<RecentErrorsPrependInput>;
  _set?: InputMaybe<RecentErrorsSetInput>;
  where: RecentErrorsBoolExp;
}>;

export type UpdateManyRecentErrorResponse = {
  __typename?: "mutation_root";
  update_recent_errors?: {
    __typename?: "recent_errors_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "recent_errors";
      created_at?: any | null;
      error_type?: any | null;
      message?: string | null;
      metadata?: any | null;
      service_name?: string | null;
      severity?: any | null;
    }>;
  } | null;
};

export type UpdateManyRecentErrorsManyVariables = Exact<{
  updates: Array<RecentErrorsUpdates> | RecentErrorsUpdates;
}>;

export type UpdateManyRecentErrorsManyResponse = {
  __typename?: "mutation_root";
  update_recent_errors_many?: Array<{
    __typename?: "recent_errors_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "recent_errors";
      created_at?: any | null;
      error_type?: any | null;
      message?: string | null;
      metadata?: any | null;
      service_name?: string | null;
      severity?: any | null;
    }>;
  } | null> | null;
};

export type UpdateManyReferralVariables = Exact<{
  _append?: InputMaybe<ReferralsAppendInput>;
  _delete_at_path?: InputMaybe<ReferralsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<ReferralsDeleteElemInput>;
  _delete_key?: InputMaybe<ReferralsDeleteKeyInput>;
  _inc?: InputMaybe<ReferralsIncInput>;
  _prepend?: InputMaybe<ReferralsPrependInput>;
  _set?: InputMaybe<ReferralsSetInput>;
  where: ReferralsBoolExp;
}>;

export type UpdateManyReferralResponse = {
  __typename?: "mutation_root";
  update_referrals?: {
    __typename?: "referrals_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "referrals";
      browser?: string | null;
      client_fingerprint?: string | null;
      conversion_value?: any | null;
      converted_at?: any | null;
      country_code?: string | null;
      created_at?: any | null;
      device_type?: string | null;
      id: any;
      ip_address?: any | null;
      is_suspicious?: boolean | null;
      landing_page?: string | null;
      last_failed_attempt?: any | null;
      referral_status?: any | null;
      referrer_code: string;
      region?: string | null;
      security_flags?: any | null;
      user_agent?: string | null;
      utm_campaign?: string | null;
      utm_medium?: string | null;
      utm_source?: string | null;
      validation_attempts?: number | null;
      visitor_id: any;
    }>;
  } | null;
};

export type UpdateOneReferralVariables = Exact<{
  _append?: InputMaybe<ReferralsAppendInput>;
  _delete_at_path?: InputMaybe<ReferralsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<ReferralsDeleteElemInput>;
  _delete_key?: InputMaybe<ReferralsDeleteKeyInput>;
  _inc?: InputMaybe<ReferralsIncInput>;
  _prepend?: InputMaybe<ReferralsPrependInput>;
  _set?: InputMaybe<ReferralsSetInput>;
  pk_columns: ReferralsPkColumnsInput;
}>;

export type UpdateOneReferralResponse = {
  __typename?: "mutation_root";
  update_referrals_by_pk?: {
    __typename?: "referrals";
    browser?: string | null;
    client_fingerprint?: string | null;
    conversion_value?: any | null;
    converted_at?: any | null;
    country_code?: string | null;
    created_at?: any | null;
    device_type?: string | null;
    id: any;
    ip_address?: any | null;
    is_suspicious?: boolean | null;
    landing_page?: string | null;
    last_failed_attempt?: any | null;
    referral_status?: any | null;
    referrer_code: string;
    region?: string | null;
    security_flags?: any | null;
    user_agent?: string | null;
    utm_campaign?: string | null;
    utm_medium?: string | null;
    utm_source?: string | null;
    validation_attempts?: number | null;
    visitor_id: any;
  } | null;
};

export type UpdateManyReferralsManyVariables = Exact<{
  updates: Array<ReferralsUpdates> | ReferralsUpdates;
}>;

export type UpdateManyReferralsManyResponse = {
  __typename?: "mutation_root";
  update_referrals_many?: Array<{
    __typename?: "referrals_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "referrals";
      browser?: string | null;
      client_fingerprint?: string | null;
      conversion_value?: any | null;
      converted_at?: any | null;
      country_code?: string | null;
      created_at?: any | null;
      device_type?: string | null;
      id: any;
      ip_address?: any | null;
      is_suspicious?: boolean | null;
      landing_page?: string | null;
      last_failed_attempt?: any | null;
      referral_status?: any | null;
      referrer_code: string;
      region?: string | null;
      security_flags?: any | null;
      user_agent?: string | null;
      utm_campaign?: string | null;
      utm_medium?: string | null;
      utm_source?: string | null;
      validation_attempts?: number | null;
      visitor_id: any;
    }>;
  } | null> | null;
};

export type UpdateManyReferrerBlockVariables = Exact<{
  _set?: InputMaybe<ReferrerBlocksSetInput>;
  where: ReferrerBlocksBoolExp;
}>;

export type UpdateManyReferrerBlockResponse = {
  __typename?: "mutation_root";
  update_referrer_blocks?: {
    __typename?: "referrer_blocks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "referrer_blocks";
      blocked_at?: any | null;
      blocked_by: string;
      created_at?: any | null;
      id: any;
      is_permanent?: boolean | null;
      reason?: string | null;
      referrer_code: string;
      updated_at?: any | null;
    }>;
  } | null;
};

export type UpdateOneReferrerBlockVariables = Exact<{
  _set?: InputMaybe<ReferrerBlocksSetInput>;
  pk_columns: ReferrerBlocksPkColumnsInput;
}>;

export type UpdateOneReferrerBlockResponse = {
  __typename?: "mutation_root";
  update_referrer_blocks_by_pk?: {
    __typename?: "referrer_blocks";
    blocked_at?: any | null;
    blocked_by: string;
    created_at?: any | null;
    id: any;
    is_permanent?: boolean | null;
    reason?: string | null;
    referrer_code: string;
    updated_at?: any | null;
  } | null;
};

export type UpdateManyReferrerBlocksManyVariables = Exact<{
  updates: Array<ReferrerBlocksUpdates> | ReferrerBlocksUpdates;
}>;

export type UpdateManyReferrerBlocksManyResponse = {
  __typename?: "mutation_root";
  update_referrer_blocks_many?: Array<{
    __typename?: "referrer_blocks_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "referrer_blocks";
      blocked_at?: any | null;
      blocked_by: string;
      created_at?: any | null;
      id: any;
      is_permanent?: boolean | null;
      reason?: string | null;
      referrer_code: string;
      updated_at?: any | null;
    }>;
  } | null> | null;
};

export type UpdateManyResearchVariables = Exact<{
  _append?: InputMaybe<ResearchAppendInput>;
  _delete_at_path?: InputMaybe<ResearchDeleteAtPathInput>;
  _delete_elem?: InputMaybe<ResearchDeleteElemInput>;
  _delete_key?: InputMaybe<ResearchDeleteKeyInput>;
  _inc?: InputMaybe<ResearchIncInput>;
  _prepend?: InputMaybe<ResearchPrependInput>;
  _set?: InputMaybe<ResearchSetInput>;
  where: ResearchBoolExp;
}>;

export type UpdateManyResearchResponse = {
  __typename?: "mutation_root";
  update_research?: {
    __typename?: "research_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      research_embedding?: {
        __typename?: "research_embeddings";
        chunk: string;
        created_at?: any | null;
        embedding?: any | null;
        embedding_review_id?: any | null;
        id: number;
        is_flagged?: boolean | null;
        research_id: any;
        updated_at: any;
        url?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneResearchVariables = Exact<{
  _append?: InputMaybe<ResearchAppendInput>;
  _delete_at_path?: InputMaybe<ResearchDeleteAtPathInput>;
  _delete_elem?: InputMaybe<ResearchDeleteElemInput>;
  _delete_key?: InputMaybe<ResearchDeleteKeyInput>;
  _inc?: InputMaybe<ResearchIncInput>;
  _prepend?: InputMaybe<ResearchPrependInput>;
  _set?: InputMaybe<ResearchSetInput>;
  pk_columns: ResearchPkColumnsInput;
}>;

export type UpdateOneResearchResponse = {
  __typename?: "mutation_root";
  update_research_by_pk?: {
    __typename?: "research";
    abstract?: string | null;
    abstract_url: string;
    affiliations?: any | null;
    authors?: any | null;
    category?: string | null;
    comments?: string | null;
    content_status: any;
    created_at: any;
    doi_url?: string | null;
    figure_count?: any | null;
    has_embedding?: boolean | null;
    id: any;
    is_flagged: boolean;
    keywords?: string | null;
    month?: string | null;
    page_count?: any | null;
    pdf_url?: string | null;
    published_at?: any | null;
    published_in?: string | null;
    summary?: string | null;
    table_count?: any | null;
    title?: string | null;
    updated_at?: any | null;
    version?: any | null;
    year?: string | null;
    content: {
      __typename?: "contents";
      content_type: any;
      created_at?: any | null;
      hot_score?: any | null;
      id: any;
      rss_url?: string | null;
      title?: string | null;
      updated_at?: any | null;
      url: string;
    };
    research_embedding?: {
      __typename?: "research_embeddings";
      chunk: string;
      created_at?: any | null;
      embedding?: any | null;
      embedding_review_id?: any | null;
      id: number;
      is_flagged?: boolean | null;
      research_id: any;
      updated_at: any;
      url?: string | null;
    } | null;
  } | null;
};

export type UpdateManyResearchEmbeddingVariables = Exact<{
  _inc?: InputMaybe<ResearchEmbeddingsIncInput>;
  _set?: InputMaybe<ResearchEmbeddingsSetInput>;
  where: ResearchEmbeddingsBoolExp;
}>;

export type UpdateManyResearchEmbeddingResponse = {
  __typename?: "mutation_root";
  update_research_embeddings?: {
    __typename?: "research_embeddings_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "research_embeddings";
      chunk: string;
      created_at?: any | null;
      embedding?: any | null;
      embedding_review_id?: any | null;
      id: number;
      is_flagged?: boolean | null;
      research_id: any;
      updated_at: any;
      url?: string | null;
      embedding_review?: {
        __typename?: "embedding_reviews";
        agent_review?: boolean | null;
        created_at: any;
        human_review?: boolean | null;
        id: any;
        notes?: string | null;
        updated_at?: any | null;
      } | null;
      research: {
        __typename?: "research";
        abstract?: string | null;
        abstract_url: string;
        affiliations?: any | null;
        authors?: any | null;
        category?: string | null;
        comments?: string | null;
        content_status: any;
        created_at: any;
        doi_url?: string | null;
        figure_count?: any | null;
        has_embedding?: boolean | null;
        id: any;
        is_flagged: boolean;
        keywords?: string | null;
        month?: string | null;
        page_count?: any | null;
        pdf_url?: string | null;
        published_at?: any | null;
        published_in?: string | null;
        summary?: string | null;
        table_count?: any | null;
        title?: string | null;
        updated_at?: any | null;
        version?: any | null;
        year?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneResearchEmbeddingVariables = Exact<{
  _inc?: InputMaybe<ResearchEmbeddingsIncInput>;
  _set?: InputMaybe<ResearchEmbeddingsSetInput>;
  pk_columns: ResearchEmbeddingsPkColumnsInput;
}>;

export type UpdateOneResearchEmbeddingResponse = {
  __typename?: "mutation_root";
  update_research_embeddings_by_pk?: {
    __typename?: "research_embeddings";
    chunk: string;
    created_at?: any | null;
    embedding?: any | null;
    embedding_review_id?: any | null;
    id: number;
    is_flagged?: boolean | null;
    research_id: any;
    updated_at: any;
    url?: string | null;
    embedding_review?: {
      __typename?: "embedding_reviews";
      agent_review?: boolean | null;
      created_at: any;
      human_review?: boolean | null;
      id: any;
      notes?: string | null;
      updated_at?: any | null;
    } | null;
    research: {
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
    };
  } | null;
};

export type UpdateManyResearchEmbeddingsManyVariables = Exact<{
  updates: Array<ResearchEmbeddingsUpdates> | ResearchEmbeddingsUpdates;
}>;

export type UpdateManyResearchEmbeddingsManyResponse = {
  __typename?: "mutation_root";
  update_research_embeddings_many?: Array<{
    __typename?: "research_embeddings_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "research_embeddings";
      chunk: string;
      created_at?: any | null;
      embedding?: any | null;
      embedding_review_id?: any | null;
      id: number;
      is_flagged?: boolean | null;
      research_id: any;
      updated_at: any;
      url?: string | null;
      embedding_review?: {
        __typename?: "embedding_reviews";
        agent_review?: boolean | null;
        created_at: any;
        human_review?: boolean | null;
        id: any;
        notes?: string | null;
        updated_at?: any | null;
      } | null;
      research: {
        __typename?: "research";
        abstract?: string | null;
        abstract_url: string;
        affiliations?: any | null;
        authors?: any | null;
        category?: string | null;
        comments?: string | null;
        content_status: any;
        created_at: any;
        doi_url?: string | null;
        figure_count?: any | null;
        has_embedding?: boolean | null;
        id: any;
        is_flagged: boolean;
        keywords?: string | null;
        month?: string | null;
        page_count?: any | null;
        pdf_url?: string | null;
        published_at?: any | null;
        published_in?: string | null;
        summary?: string | null;
        table_count?: any | null;
        title?: string | null;
        updated_at?: any | null;
        version?: any | null;
        year?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyResearchManyVariables = Exact<{
  updates: Array<ResearchUpdates> | ResearchUpdates;
}>;

export type UpdateManyResearchManyResponse = {
  __typename?: "mutation_root";
  update_research_many?: Array<{
    __typename?: "research_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "research";
      abstract?: string | null;
      abstract_url: string;
      affiliations?: any | null;
      authors?: any | null;
      category?: string | null;
      comments?: string | null;
      content_status: any;
      created_at: any;
      doi_url?: string | null;
      figure_count?: any | null;
      has_embedding?: boolean | null;
      id: any;
      is_flagged: boolean;
      keywords?: string | null;
      month?: string | null;
      page_count?: any | null;
      pdf_url?: string | null;
      published_at?: any | null;
      published_in?: string | null;
      summary?: string | null;
      table_count?: any | null;
      title?: string | null;
      updated_at?: any | null;
      version?: any | null;
      year?: string | null;
      content: {
        __typename?: "contents";
        content_type: any;
        created_at?: any | null;
        hot_score?: any | null;
        id: any;
        rss_url?: string | null;
        title?: string | null;
        updated_at?: any | null;
        url: string;
      };
      research_embedding?: {
        __typename?: "research_embeddings";
        chunk: string;
        created_at?: any | null;
        embedding?: any | null;
        embedding_review_id?: any | null;
        id: number;
        is_flagged?: boolean | null;
        research_id: any;
        updated_at: any;
        url?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyResponseVariables = Exact<{
  _inc?: InputMaybe<ResponsesIncInput>;
  _set?: InputMaybe<ResponsesSetInput>;
  where: ResponsesBoolExp;
}>;

export type UpdateManyResponseResponse = {
  __typename?: "mutation_root";
  update_responses?: {
    __typename?: "responses_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "responses";
      created_at?: any | null;
      downvotes?: number | null;
      id: any;
      output: string;
      search_id: any;
      upvotes?: number | null;
      search: {
        __typename?: "searches";
        created_at?: any | null;
        embedding?: any | null;
        id: any;
        input: string;
        tokens_used?: any | null;
        user_ids?: Array<any> | null;
      };
    }>;
  } | null;
};

export type UpdateOneResponseVariables = Exact<{
  _inc?: InputMaybe<ResponsesIncInput>;
  _set?: InputMaybe<ResponsesSetInput>;
  pk_columns: ResponsesPkColumnsInput;
}>;

export type UpdateOneResponseResponse = {
  __typename?: "mutation_root";
  update_responses_by_pk?: {
    __typename?: "responses";
    created_at?: any | null;
    downvotes?: number | null;
    id: any;
    output: string;
    search_id: any;
    upvotes?: number | null;
    search: {
      __typename?: "searches";
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      input: string;
      tokens_used?: any | null;
      user_ids?: Array<any> | null;
    };
  } | null;
};

export type UpdateManyResponsesManyVariables = Exact<{
  updates: Array<ResponsesUpdates> | ResponsesUpdates;
}>;

export type UpdateManyResponsesManyResponse = {
  __typename?: "mutation_root";
  update_responses_many?: Array<{
    __typename?: "responses_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "responses";
      created_at?: any | null;
      downvotes?: number | null;
      id: any;
      output: string;
      search_id: any;
      upvotes?: number | null;
      search: {
        __typename?: "searches";
        created_at?: any | null;
        embedding?: any | null;
        id: any;
        input: string;
        tokens_used?: any | null;
        user_ids?: Array<any> | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyRoleHierarchyVariables = Exact<{
  _set?: InputMaybe<RoleHierarchySetInput>;
  where: RoleHierarchyBoolExp;
}>;

export type UpdateManyRoleHierarchyResponse = {
  __typename?: "mutation_root";
  update_role_hierarchy?: {
    __typename?: "role_hierarchy_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "role_hierarchy";
      child_role: any;
      parent_role: any;
    }>;
  } | null;
};

export type UpdateOneRoleHierarchyVariables = Exact<{
  _set?: InputMaybe<RoleHierarchySetInput>;
  pk_columns: RoleHierarchyPkColumnsInput;
}>;

export type UpdateOneRoleHierarchyResponse = {
  __typename?: "mutation_root";
  update_role_hierarchy_by_pk?: {
    __typename?: "role_hierarchy";
    child_role: any;
    parent_role: any;
  } | null;
};

export type UpdateManyRoleHierarchyManyVariables = Exact<{
  updates: Array<RoleHierarchyUpdates> | RoleHierarchyUpdates;
}>;

export type UpdateManyRoleHierarchyManyResponse = {
  __typename?: "mutation_root";
  update_role_hierarchy_many?: Array<{
    __typename?: "role_hierarchy_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "role_hierarchy";
      child_role: any;
      parent_role: any;
    }>;
  } | null> | null;
};

export type UpdateManyRolePermissionVariables = Exact<{
  _append?: InputMaybe<RolePermissionsAppendInput>;
  _delete_at_path?: InputMaybe<RolePermissionsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<RolePermissionsDeleteElemInput>;
  _delete_key?: InputMaybe<RolePermissionsDeleteKeyInput>;
  _inc?: InputMaybe<RolePermissionsIncInput>;
  _prepend?: InputMaybe<RolePermissionsPrependInput>;
  _set?: InputMaybe<RolePermissionsSetInput>;
  where: RolePermissionsBoolExp;
}>;

export type UpdateManyRolePermissionResponse = {
  __typename?: "mutation_root";
  update_role_permissions?: {
    __typename?: "role_permissions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "role_permissions";
      cached_permissions?: any | null;
      conditions?: any | null;
      id: number;
      inherit_from?: Array<any> | null;
      last_updated?: any | null;
      permissions?: any | null;
      role: any;
      table_name: string;
    }>;
  } | null;
};

export type UpdateOneRolePermissionVariables = Exact<{
  _append?: InputMaybe<RolePermissionsAppendInput>;
  _delete_at_path?: InputMaybe<RolePermissionsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<RolePermissionsDeleteElemInput>;
  _delete_key?: InputMaybe<RolePermissionsDeleteKeyInput>;
  _inc?: InputMaybe<RolePermissionsIncInput>;
  _prepend?: InputMaybe<RolePermissionsPrependInput>;
  _set?: InputMaybe<RolePermissionsSetInput>;
  pk_columns: RolePermissionsPkColumnsInput;
}>;

export type UpdateOneRolePermissionResponse = {
  __typename?: "mutation_root";
  update_role_permissions_by_pk?: {
    __typename?: "role_permissions";
    cached_permissions?: any | null;
    conditions?: any | null;
    id: number;
    inherit_from?: Array<any> | null;
    last_updated?: any | null;
    permissions?: any | null;
    role: any;
    table_name: string;
  } | null;
};

export type UpdateManyRolePermissionsManyVariables = Exact<{
  updates: Array<RolePermissionsUpdates> | RolePermissionsUpdates;
}>;

export type UpdateManyRolePermissionsManyResponse = {
  __typename?: "mutation_root";
  update_role_permissions_many?: Array<{
    __typename?: "role_permissions_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "role_permissions";
      cached_permissions?: any | null;
      conditions?: any | null;
      id: number;
      inherit_from?: Array<any> | null;
      last_updated?: any | null;
      permissions?: any | null;
      role: any;
      table_name: string;
    }>;
  } | null> | null;
};

export type UpdateManyRolePermissionsMaterializedVariables = Exact<{
  _append?: InputMaybe<RolePermissionsMaterializedAppendInput>;
  _delete_at_path?: InputMaybe<RolePermissionsMaterializedDeleteAtPathInput>;
  _delete_elem?: InputMaybe<RolePermissionsMaterializedDeleteElemInput>;
  _delete_key?: InputMaybe<RolePermissionsMaterializedDeleteKeyInput>;
  _prepend?: InputMaybe<RolePermissionsMaterializedPrependInput>;
  _set?: InputMaybe<RolePermissionsMaterializedSetInput>;
  where: RolePermissionsMaterializedBoolExp;
}>;

export type UpdateManyRolePermissionsMaterializedResponse = {
  __typename?: "mutation_root";
  update_role_permissions_materialized?: {
    __typename?: "role_permissions_materialized_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "role_permissions_materialized";
      last_updated?: any | null;
      permissions: any;
      role: any;
    }>;
  } | null;
};

export type UpdateOneRolePermissionsMaterializedVariables = Exact<{
  _append?: InputMaybe<RolePermissionsMaterializedAppendInput>;
  _delete_at_path?: InputMaybe<RolePermissionsMaterializedDeleteAtPathInput>;
  _delete_elem?: InputMaybe<RolePermissionsMaterializedDeleteElemInput>;
  _delete_key?: InputMaybe<RolePermissionsMaterializedDeleteKeyInput>;
  _prepend?: InputMaybe<RolePermissionsMaterializedPrependInput>;
  _set?: InputMaybe<RolePermissionsMaterializedSetInput>;
  pk_columns: RolePermissionsMaterializedPkColumnsInput;
}>;

export type UpdateOneRolePermissionsMaterializedResponse = {
  __typename?: "mutation_root";
  update_role_permissions_materialized_by_pk?: {
    __typename?: "role_permissions_materialized";
    last_updated?: any | null;
    permissions: any;
    role: any;
  } | null;
};

export type UpdateManyRolePermissionsMaterializedManyVariables = Exact<{
  updates:
    | Array<RolePermissionsMaterializedUpdates>
    | RolePermissionsMaterializedUpdates;
}>;

export type UpdateManyRolePermissionsMaterializedManyResponse = {
  __typename?: "mutation_root";
  update_role_permissions_materialized_many?: Array<{
    __typename?: "role_permissions_materialized_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "role_permissions_materialized";
      last_updated?: any | null;
      permissions: any;
      role: any;
    }>;
  } | null> | null;
};

export type UpdateManyScoringWeightVariables = Exact<{
  _inc?: InputMaybe<ScoringWeightsIncInput>;
  _set?: InputMaybe<ScoringWeightsSetInput>;
  where: ScoringWeightsBoolExp;
}>;

export type UpdateManyScoringWeightResponse = {
  __typename?: "mutation_root";
  update_scoring_weights?: {
    __typename?: "scoring_weights_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "scoring_weights";
      description?: string | null;
      id: any;
      name: string;
      updated_at?: any | null;
      weight: any;
    }>;
  } | null;
};

export type UpdateOneScoringWeightVariables = Exact<{
  _inc?: InputMaybe<ScoringWeightsIncInput>;
  _set?: InputMaybe<ScoringWeightsSetInput>;
  pk_columns: ScoringWeightsPkColumnsInput;
}>;

export type UpdateOneScoringWeightResponse = {
  __typename?: "mutation_root";
  update_scoring_weights_by_pk?: {
    __typename?: "scoring_weights";
    description?: string | null;
    id: any;
    name: string;
    updated_at?: any | null;
    weight: any;
  } | null;
};

export type UpdateManyScoringWeightsManyVariables = Exact<{
  updates: Array<ScoringWeightsUpdates> | ScoringWeightsUpdates;
}>;

export type UpdateManyScoringWeightsManyResponse = {
  __typename?: "mutation_root";
  update_scoring_weights_many?: Array<{
    __typename?: "scoring_weights_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "scoring_weights";
      description?: string | null;
      id: any;
      name: string;
      updated_at?: any | null;
      weight: any;
    }>;
  } | null> | null;
};

export type UpdateManySearchVariables = Exact<{
  _inc?: InputMaybe<SearchesIncInput>;
  _set?: InputMaybe<SearchesSetInput>;
  where: SearchesBoolExp;
}>;

export type UpdateManySearchResponse = {
  __typename?: "mutation_root";
  update_searches?: {
    __typename?: "searches_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "searches";
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      input: string;
      tokens_used?: any | null;
      user_ids?: Array<any> | null;
      responses: Array<{
        __typename?: "responses";
        created_at?: any | null;
        downvotes?: number | null;
        id: any;
        output: string;
        search_id: any;
        upvotes?: number | null;
      }>;
    }>;
  } | null;
};

export type UpdateOneSearchVariables = Exact<{
  _inc?: InputMaybe<SearchesIncInput>;
  _set?: InputMaybe<SearchesSetInput>;
  pk_columns: SearchesPkColumnsInput;
}>;

export type UpdateOneSearchResponse = {
  __typename?: "mutation_root";
  update_searches_by_pk?: {
    __typename?: "searches";
    created_at?: any | null;
    embedding?: any | null;
    id: any;
    input: string;
    tokens_used?: any | null;
    user_ids?: Array<any> | null;
    responses: Array<{
      __typename?: "responses";
      created_at?: any | null;
      downvotes?: number | null;
      id: any;
      output: string;
      search_id: any;
      upvotes?: number | null;
    }>;
  } | null;
};

export type UpdateManySearchesManyVariables = Exact<{
  updates: Array<SearchesUpdates> | SearchesUpdates;
}>;

export type UpdateManySearchesManyResponse = {
  __typename?: "mutation_root";
  update_searches_many?: Array<{
    __typename?: "searches_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "searches";
      created_at?: any | null;
      embedding?: any | null;
      id: any;
      input: string;
      tokens_used?: any | null;
      user_ids?: Array<any> | null;
      responses: Array<{
        __typename?: "responses";
        created_at?: any | null;
        downvotes?: number | null;
        id: any;
        output: string;
        search_id: any;
        upvotes?: number | null;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManySocialMediaVariables = Exact<{
  _inc?: InputMaybe<SocialMediaIncInput>;
  _set?: InputMaybe<SocialMediaSetInput>;
  where: SocialMediaBoolExp;
}>;

export type UpdateManySocialMediaResponse = {
  __typename?: "mutation_root";
  update_social_media?: {
    __typename?: "social_media_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "social_media";
      created_at?: any | null;
      facebook_url?: string | null;
      id: number;
      instagram_url?: string | null;
      linkedin_url?: string | null;
      twitter_url?: string | null;
      updated_at?: any | null;
      youtube_url?: string | null;
      companies: Array<{
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      }>;
    }>;
  } | null;
};

export type UpdateOneSocialMediaVariables = Exact<{
  _inc?: InputMaybe<SocialMediaIncInput>;
  _set?: InputMaybe<SocialMediaSetInput>;
  pk_columns: SocialMediaPkColumnsInput;
}>;

export type UpdateOneSocialMediaResponse = {
  __typename?: "mutation_root";
  update_social_media_by_pk?: {
    __typename?: "social_media";
    created_at?: any | null;
    facebook_url?: string | null;
    id: number;
    instagram_url?: string | null;
    linkedin_url?: string | null;
    twitter_url?: string | null;
    updated_at?: any | null;
    youtube_url?: string | null;
    companies: Array<{
      __typename?: "companies";
      category?: string | null;
      category_id?: any | null;
      content_status: any;
      created_at?: any | null;
      description?: string | null;
      failed_count?: any | null;
      founding_year?: any | null;
      id: any;
      is_english?: boolean | null;
      is_government?: boolean | null;
      keywords?: any | null;
      logo_url?: string | null;
      name?: string | null;
      scrape_frequency?: any | null;
      scrape_rating?: any | null;
      scraped_at?: any | null;
      social_media_id?: number | null;
      updated_at?: any | null;
      url: string;
    }>;
  } | null;
};

export type UpdateManySocialMediaManyVariables = Exact<{
  updates: Array<SocialMediaUpdates> | SocialMediaUpdates;
}>;

export type UpdateManySocialMediaManyResponse = {
  __typename?: "mutation_root";
  update_social_media_many?: Array<{
    __typename?: "social_media_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "social_media";
      created_at?: any | null;
      facebook_url?: string | null;
      id: number;
      instagram_url?: string | null;
      linkedin_url?: string | null;
      twitter_url?: string | null;
      updated_at?: any | null;
      youtube_url?: string | null;
      companies: Array<{
        __typename?: "companies";
        category?: string | null;
        category_id?: any | null;
        content_status: any;
        created_at?: any | null;
        description?: string | null;
        failed_count?: any | null;
        founding_year?: any | null;
        id: any;
        is_english?: boolean | null;
        is_government?: boolean | null;
        keywords?: any | null;
        logo_url?: string | null;
        name?: string | null;
        scrape_frequency?: any | null;
        scrape_rating?: any | null;
        scraped_at?: any | null;
        social_media_id?: number | null;
        updated_at?: any | null;
        url: string;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManySpiderMetricVariables = Exact<{
  _append?: InputMaybe<SpiderMetricsAppendInput>;
  _delete_at_path?: InputMaybe<SpiderMetricsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<SpiderMetricsDeleteElemInput>;
  _delete_key?: InputMaybe<SpiderMetricsDeleteKeyInput>;
  _inc?: InputMaybe<SpiderMetricsIncInput>;
  _prepend?: InputMaybe<SpiderMetricsPrependInput>;
  _set?: InputMaybe<SpiderMetricsSetInput>;
  where: SpiderMetricsBoolExp;
}>;

export type UpdateManySpiderMetricResponse = {
  __typename?: "mutation_root";
  update_spider_metrics?: {
    __typename?: "spider_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "spider_metrics";
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
      metric_definition?: {
        __typename?: "metric_definitions";
        category?: string | null;
        description?: string | null;
        id: number;
        is_dimensional?: boolean | null;
        name: string;
        type: string;
        unit?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneSpiderMetricVariables = Exact<{
  _append?: InputMaybe<SpiderMetricsAppendInput>;
  _delete_at_path?: InputMaybe<SpiderMetricsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<SpiderMetricsDeleteElemInput>;
  _delete_key?: InputMaybe<SpiderMetricsDeleteKeyInput>;
  _inc?: InputMaybe<SpiderMetricsIncInput>;
  _prepend?: InputMaybe<SpiderMetricsPrependInput>;
  _set?: InputMaybe<SpiderMetricsSetInput>;
  pk_columns: SpiderMetricsPkColumnsInput;
}>;

export type UpdateOneSpiderMetricResponse = {
  __typename?: "mutation_root";
  update_spider_metrics_by_pk?: {
    __typename?: "spider_metrics";
    crawl_id: any;
    id: any;
    metric_id?: number | null;
    timestamp: any;
    value: any;
    metric_definition?: {
      __typename?: "metric_definitions";
      category?: string | null;
      description?: string | null;
      id: number;
      is_dimensional?: boolean | null;
      name: string;
      type: string;
      unit?: string | null;
    } | null;
  } | null;
};

export type UpdateManySpiderMetricsManyVariables = Exact<{
  updates: Array<SpiderMetricsUpdates> | SpiderMetricsUpdates;
}>;

export type UpdateManySpiderMetricsManyResponse = {
  __typename?: "mutation_root";
  update_spider_metrics_many?: Array<{
    __typename?: "spider_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "spider_metrics";
      crawl_id: any;
      id: any;
      metric_id?: number | null;
      timestamp: any;
      value: any;
      metric_definition?: {
        __typename?: "metric_definitions";
        category?: string | null;
        description?: string | null;
        id: number;
        is_dimensional?: boolean | null;
        name: string;
        type: string;
        unit?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyStrapiMigrationVariables = Exact<{
  _inc?: InputMaybe<StrapiMigrationsIncInput>;
  _set?: InputMaybe<StrapiMigrationsSetInput>;
  where: StrapiMigrationsBoolExp;
}>;

export type UpdateManyStrapiMigrationResponse = {
  __typename?: "mutation_root";
  update_strapi_migrations?: {
    __typename?: "strapi_migrations_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "strapi_migrations";
      id: number;
      name?: string | null;
      time?: any | null;
    }>;
  } | null;
};

export type UpdateOneStrapiMigrationVariables = Exact<{
  _inc?: InputMaybe<StrapiMigrationsIncInput>;
  _set?: InputMaybe<StrapiMigrationsSetInput>;
  pk_columns: StrapiMigrationsPkColumnsInput;
}>;

export type UpdateOneStrapiMigrationResponse = {
  __typename?: "mutation_root";
  update_strapi_migrations_by_pk?: {
    __typename?: "strapi_migrations";
    id: number;
    name?: string | null;
    time?: any | null;
  } | null;
};

export type UpdateManyStrapiMigrationsInternalVariables = Exact<{
  _inc?: InputMaybe<StrapiMigrationsInternalIncInput>;
  _set?: InputMaybe<StrapiMigrationsInternalSetInput>;
  where: StrapiMigrationsInternalBoolExp;
}>;

export type UpdateManyStrapiMigrationsInternalResponse = {
  __typename?: "mutation_root";
  update_strapi_migrations_internal?: {
    __typename?: "strapi_migrations_internal_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "strapi_migrations_internal";
      id: number;
      name?: string | null;
      time?: any | null;
    }>;
  } | null;
};

export type UpdateOneStrapiMigrationsInternalVariables = Exact<{
  _inc?: InputMaybe<StrapiMigrationsInternalIncInput>;
  _set?: InputMaybe<StrapiMigrationsInternalSetInput>;
  pk_columns: StrapiMigrationsInternalPkColumnsInput;
}>;

export type UpdateOneStrapiMigrationsInternalResponse = {
  __typename?: "mutation_root";
  update_strapi_migrations_internal_by_pk?: {
    __typename?: "strapi_migrations_internal";
    id: number;
    name?: string | null;
    time?: any | null;
  } | null;
};

export type UpdateManyStrapiMigrationsInternalManyVariables = Exact<{
  updates:
    | Array<StrapiMigrationsInternalUpdates>
    | StrapiMigrationsInternalUpdates;
}>;

export type UpdateManyStrapiMigrationsInternalManyResponse = {
  __typename?: "mutation_root";
  update_strapi_migrations_internal_many?: Array<{
    __typename?: "strapi_migrations_internal_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "strapi_migrations_internal";
      id: number;
      name?: string | null;
      time?: any | null;
    }>;
  } | null> | null;
};

export type UpdateManyStrapiMigrationsManyVariables = Exact<{
  updates: Array<StrapiMigrationsUpdates> | StrapiMigrationsUpdates;
}>;

export type UpdateManyStrapiMigrationsManyResponse = {
  __typename?: "mutation_root";
  update_strapi_migrations_many?: Array<{
    __typename?: "strapi_migrations_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "strapi_migrations";
      id: number;
      name?: string | null;
      time?: any | null;
    }>;
  } | null> | null;
};

export type UpdateManyTableMaintenanceLogVariables = Exact<{
  _inc?: InputMaybe<TableMaintenanceLogIncInput>;
  _set?: InputMaybe<TableMaintenanceLogSetInput>;
  where: TableMaintenanceLogBoolExp;
}>;

export type UpdateManyTableMaintenanceLogResponse = {
  __typename?: "mutation_root";
  update_table_maintenance_log?: {
    __typename?: "table_maintenance_log_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_maintenance_log";
      detail?: string | null;
      id: number;
      logged_at?: any | null;
      operation?: string | null;
    }>;
  } | null;
};

export type UpdateOneTableMaintenanceLogVariables = Exact<{
  _inc?: InputMaybe<TableMaintenanceLogIncInput>;
  _set?: InputMaybe<TableMaintenanceLogSetInput>;
  pk_columns: TableMaintenanceLogPkColumnsInput;
}>;

export type UpdateOneTableMaintenanceLogResponse = {
  __typename?: "mutation_root";
  update_table_maintenance_log_by_pk?: {
    __typename?: "table_maintenance_log";
    detail?: string | null;
    id: number;
    logged_at?: any | null;
    operation?: string | null;
  } | null;
};

export type UpdateManyTableMaintenanceLogManyVariables = Exact<{
  updates: Array<TableMaintenanceLogUpdates> | TableMaintenanceLogUpdates;
}>;

export type UpdateManyTableMaintenanceLogManyResponse = {
  __typename?: "mutation_root";
  update_table_maintenance_log_many?: Array<{
    __typename?: "table_maintenance_log_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_maintenance_log";
      detail?: string | null;
      id: number;
      logged_at?: any | null;
      operation?: string | null;
    }>;
  } | null> | null;
};

export type UpdateManyTableQueryPerformanceVariables = Exact<{
  _inc?: InputMaybe<TableQueryPerformanceIncInput>;
  _set?: InputMaybe<TableQueryPerformanceSetInput>;
  where: TableQueryPerformanceBoolExp;
}>;

export type UpdateManyTableQueryPerformanceResponse = {
  __typename?: "mutation_root";
  update_table_query_performance?: {
    __typename?: "table_query_performance_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_query_performance";
      avg_duration?: any | null;
      capture_time?: any | null;
      execution_count?: any | null;
      query?: string | null;
    }>;
  } | null;
};

export type UpdateManyTableQueryPerformanceManyVariables = Exact<{
  updates: Array<TableQueryPerformanceUpdates> | TableQueryPerformanceUpdates;
}>;

export type UpdateManyTableQueryPerformanceManyResponse = {
  __typename?: "mutation_root";
  update_table_query_performance_many?: Array<{
    __typename?: "table_query_performance_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_query_performance";
      avg_duration?: any | null;
      capture_time?: any | null;
      execution_count?: any | null;
      query?: string | null;
    }>;
  } | null> | null;
};

export type UpdateManyTableSequenceUsageVariables = Exact<{
  _inc?: InputMaybe<TableSequenceUsageIncInput>;
  _set?: InputMaybe<TableSequenceUsageSetInput>;
  where: TableSequenceUsageBoolExp;
}>;

export type UpdateManyTableSequenceUsageResponse = {
  __typename?: "mutation_root";
  update_table_sequence_usage?: {
    __typename?: "table_sequence_usage_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_sequence_usage";
      capture_time?: any | null;
      current_value?: any | null;
      max_value?: any | null;
      sequence_name?: string | null;
    }>;
  } | null;
};

export type UpdateManyTableSequenceUsageManyVariables = Exact<{
  updates: Array<TableSequenceUsageUpdates> | TableSequenceUsageUpdates;
}>;

export type UpdateManyTableSequenceUsageManyResponse = {
  __typename?: "mutation_root";
  update_table_sequence_usage_many?: Array<{
    __typename?: "table_sequence_usage_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_sequence_usage";
      capture_time?: any | null;
      current_value?: any | null;
      max_value?: any | null;
      sequence_name?: string | null;
    }>;
  } | null> | null;
};

export type UpdateManyTableStatisticVariables = Exact<{
  _append?: InputMaybe<TableStatisticsAppendInput>;
  _delete_at_path?: InputMaybe<TableStatisticsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<TableStatisticsDeleteElemInput>;
  _delete_key?: InputMaybe<TableStatisticsDeleteKeyInput>;
  _inc?: InputMaybe<TableStatisticsIncInput>;
  _prepend?: InputMaybe<TableStatisticsPrependInput>;
  _set?: InputMaybe<TableStatisticsSetInput>;
  where: TableStatisticsBoolExp;
}>;

export type UpdateManyTableStatisticResponse = {
  __typename?: "mutation_root";
  update_table_statistics?: {
    __typename?: "table_statistics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_statistics";
      buffer_cache_hit_ratio?: any | null;
      capture_time: any;
      dead_tuples?: any | null;
      estimated_bloat_ratio?: any | null;
      index_scan_count?: any | null;
      index_size?: any | null;
      index_usage?: any | null;
      last_analyze?: any | null;
      last_vacuum?: any | null;
      live_tuples?: any | null;
      row_count?: any | null;
      seq_scan_count?: any | null;
      table_name: string;
      table_size?: any | null;
    }>;
  } | null;
};

export type UpdateOneTableStatisticVariables = Exact<{
  _append?: InputMaybe<TableStatisticsAppendInput>;
  _delete_at_path?: InputMaybe<TableStatisticsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<TableStatisticsDeleteElemInput>;
  _delete_key?: InputMaybe<TableStatisticsDeleteKeyInput>;
  _inc?: InputMaybe<TableStatisticsIncInput>;
  _prepend?: InputMaybe<TableStatisticsPrependInput>;
  _set?: InputMaybe<TableStatisticsSetInput>;
  pk_columns: TableStatisticsPkColumnsInput;
}>;

export type UpdateOneTableStatisticResponse = {
  __typename?: "mutation_root";
  update_table_statistics_by_pk?: {
    __typename?: "table_statistics";
    buffer_cache_hit_ratio?: any | null;
    capture_time: any;
    dead_tuples?: any | null;
    estimated_bloat_ratio?: any | null;
    index_scan_count?: any | null;
    index_size?: any | null;
    index_usage?: any | null;
    last_analyze?: any | null;
    last_vacuum?: any | null;
    live_tuples?: any | null;
    row_count?: any | null;
    seq_scan_count?: any | null;
    table_name: string;
    table_size?: any | null;
  } | null;
};

export type UpdateManyTableStatisticsManyVariables = Exact<{
  updates: Array<TableStatisticsUpdates> | TableStatisticsUpdates;
}>;

export type UpdateManyTableStatisticsManyResponse = {
  __typename?: "mutation_root";
  update_table_statistics_many?: Array<{
    __typename?: "table_statistics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "table_statistics";
      buffer_cache_hit_ratio?: any | null;
      capture_time: any;
      dead_tuples?: any | null;
      estimated_bloat_ratio?: any | null;
      index_scan_count?: any | null;
      index_size?: any | null;
      index_usage?: any | null;
      last_analyze?: any | null;
      last_vacuum?: any | null;
      live_tuples?: any | null;
      row_count?: any | null;
      seq_scan_count?: any | null;
      table_name: string;
      table_size?: any | null;
    }>;
  } | null> | null;
};

export type UpdateManyTagVariables = Exact<{
  _inc?: InputMaybe<TagsIncInput>;
  _set?: InputMaybe<TagsSetInput>;
  where: TagsBoolExp;
}>;

export type UpdateManyTagResponse = {
  __typename?: "mutation_root";
  update_tags?: {
    __typename?: "tags_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "tags";
      body?: string | null;
      created_at?: any | null;
      document_id?: string | null;
      id: number;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
      content_tags: Array<{
        __typename?: "content_tags";
        content_id: any;
        tag_id: number;
      }>;
      news_tags: Array<{
        __typename?: "news_tags";
        id: number;
        news_id?: any | null;
        tag_id: number;
      }>;
    }>;
  } | null;
};

export type UpdateOneTagVariables = Exact<{
  _inc?: InputMaybe<TagsIncInput>;
  _set?: InputMaybe<TagsSetInput>;
  pk_columns: TagsPkColumnsInput;
}>;

export type UpdateOneTagResponse = {
  __typename?: "mutation_root";
  update_tags_by_pk?: {
    __typename?: "tags";
    body?: string | null;
    created_at?: any | null;
    document_id?: string | null;
    id: number;
    locale?: string | null;
    name: string;
    published_at?: string | null;
    updated_at?: any | null;
    content_tags: Array<{
      __typename?: "content_tags";
      content_id: any;
      tag_id: number;
    }>;
    news_tags: Array<{
      __typename?: "news_tags";
      id: number;
      news_id?: any | null;
      tag_id: number;
    }>;
  } | null;
};

export type UpdateManyTagsManyVariables = Exact<{
  updates: Array<TagsUpdates> | TagsUpdates;
}>;

export type UpdateManyTagsManyResponse = {
  __typename?: "mutation_root";
  update_tags_many?: Array<{
    __typename?: "tags_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "tags";
      body?: string | null;
      created_at?: any | null;
      document_id?: string | null;
      id: number;
      locale?: string | null;
      name: string;
      published_at?: string | null;
      updated_at?: any | null;
      content_tags: Array<{
        __typename?: "content_tags";
        content_id: any;
        tag_id: number;
      }>;
      news_tags: Array<{
        __typename?: "news_tags";
        id: number;
        news_id?: any | null;
        tag_id: number;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyUserMetricVariables = Exact<{
  _append?: InputMaybe<UserMetricsAppendInput>;
  _delete_at_path?: InputMaybe<UserMetricsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<UserMetricsDeleteElemInput>;
  _delete_key?: InputMaybe<UserMetricsDeleteKeyInput>;
  _inc?: InputMaybe<UserMetricsIncInput>;
  _prepend?: InputMaybe<UserMetricsPrependInput>;
  _set?: InputMaybe<UserMetricsSetInput>;
  where: UserMetricsBoolExp;
}>;

export type UpdateManyUserMetricResponse = {
  __typename?: "mutation_root";
  update_user_metrics?: {
    __typename?: "user_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "user_metrics";
      achievements?: any | null;
      best_streak?: number | null;
      created_at?: any | null;
      current_level?: number | null;
      current_streak?: number | null;
      current_xp?: number | null;
      downvote_count?: number | null;
      id: any;
      interaction_stats?: any | null;
      last_vote_date?: any | null;
      multipliers?: any | null;
      points?: number | null;
      points_breakdown?: any | null;
      titles?: any | null;
      today_vote_count?: number | null;
      total_reading_time?: number | null;
      total_votes?: number | null;
      updated_at?: any | null;
      upvote_count?: number | null;
      user_id: any;
      vote_accuracy?: any | null;
      xp_to_next_level?: number | null;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneUserMetricVariables = Exact<{
  _append?: InputMaybe<UserMetricsAppendInput>;
  _delete_at_path?: InputMaybe<UserMetricsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<UserMetricsDeleteElemInput>;
  _delete_key?: InputMaybe<UserMetricsDeleteKeyInput>;
  _inc?: InputMaybe<UserMetricsIncInput>;
  _prepend?: InputMaybe<UserMetricsPrependInput>;
  _set?: InputMaybe<UserMetricsSetInput>;
  pk_columns: UserMetricsPkColumnsInput;
}>;

export type UpdateOneUserMetricResponse = {
  __typename?: "mutation_root";
  update_user_metrics_by_pk?: {
    __typename?: "user_metrics";
    achievements?: any | null;
    best_streak?: number | null;
    created_at?: any | null;
    current_level?: number | null;
    current_streak?: number | null;
    current_xp?: number | null;
    downvote_count?: number | null;
    id: any;
    interaction_stats?: any | null;
    last_vote_date?: any | null;
    multipliers?: any | null;
    points?: number | null;
    points_breakdown?: any | null;
    titles?: any | null;
    today_vote_count?: number | null;
    total_reading_time?: number | null;
    total_votes?: number | null;
    updated_at?: any | null;
    upvote_count?: number | null;
    user_id: any;
    vote_accuracy?: any | null;
    xp_to_next_level?: number | null;
    user_profile: {
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
    };
  } | null;
};

export type UpdateManyUserMetricsManyVariables = Exact<{
  updates: Array<UserMetricsUpdates> | UserMetricsUpdates;
}>;

export type UpdateManyUserMetricsManyResponse = {
  __typename?: "mutation_root";
  update_user_metrics_many?: Array<{
    __typename?: "user_metrics_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "user_metrics";
      achievements?: any | null;
      best_streak?: number | null;
      created_at?: any | null;
      current_level?: number | null;
      current_streak?: number | null;
      current_xp?: number | null;
      downvote_count?: number | null;
      id: any;
      interaction_stats?: any | null;
      last_vote_date?: any | null;
      multipliers?: any | null;
      points?: number | null;
      points_breakdown?: any | null;
      titles?: any | null;
      today_vote_count?: number | null;
      total_reading_time?: number | null;
      total_votes?: number | null;
      updated_at?: any | null;
      upvote_count?: number | null;
      user_id: any;
      vote_accuracy?: any | null;
      xp_to_next_level?: number | null;
      user_profile: {
        __typename?: "user_profiles";
        avatar?: string | null;
        created_at?: any | null;
        dob?: any | null;
        email: string;
        followed_count?: number | null;
        followers_count?: number | null;
        gender_id?: any | null;
        given_name?: string | null;
        id: any;
        introduction?: string | null;
        is_active?: boolean | null;
        last_seen?: any | null;
        plan?: any | null;
        role: any;
        surname?: string | null;
        updated_at?: any | null;
        username?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyUserProfileVariables = Exact<{
  _inc?: InputMaybe<UserProfilesIncInput>;
  _set?: InputMaybe<UserProfilesSetInput>;
  where: UserProfilesBoolExp;
}>;

export type UpdateManyUserProfileResponse = {
  __typename?: "mutation_root";
  update_user_profiles?: {
    __typename?: "user_profiles_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      comments: Array<{
        __typename?: "comments";
        content: string;
        content_id: any;
        content_type: any;
        created_at?: any | null;
        id: any;
        parent_comment_id?: any | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      company_employees: Array<{
        __typename?: "company_employees";
        access_level: any;
        company_id?: any | null;
        created_at?: any | null;
        end_date?: any | null;
        id: any;
        job_description?: string | null;
        role: string;
        start_date?: any | null;
        status?: boolean | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      contacts: Array<{
        __typename?: "contacts";
        company_id?: any | null;
        contact_type?: any | null;
        created_at?: any | null;
        email?: string | null;
        id: number;
        is_primary?: boolean | null;
        phone?: string | null;
        privacy_level?: any | null;
        title?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      content_source_visits: Array<{
        __typename?: "content_source_visits";
        content_id: any;
        created_at?: any | null;
        id: any;
        user_id?: any | null;
      }>;
      customer_payments: Array<{
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      }>;
      customer_subscriptions: Array<{
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      feedbacks: Array<{
        __typename?: "feedbacks";
        created_at: any;
        device_info?: string | null;
        feedback_status?: any | null;
        feedback_type?: any | null;
        id: number;
        message: string;
        page_identifier: string;
        rating?: number | null;
        resolution_comment?: string | null;
        updated_at: any;
        user_id?: any | null;
      }>;
      feeds: Array<{
        __typename?: "feeds";
        created_at: any;
        id: any;
        name?: string | null;
        user_id?: any | null;
      }>;
      follows: Array<{
        __typename?: "follows";
        created_at?: any | null;
        followed_entity: any;
        followed_id: any;
        id: any;
        user_id: any;
      }>;
      user_metric?: {
        __typename?: "user_metrics";
        achievements?: any | null;
        best_streak?: number | null;
        created_at?: any | null;
        current_level?: number | null;
        current_streak?: number | null;
        current_xp?: number | null;
        downvote_count?: number | null;
        id: any;
        interaction_stats?: any | null;
        last_vote_date?: any | null;
        multipliers?: any | null;
        points?: number | null;
        points_breakdown?: any | null;
        titles?: any | null;
        today_vote_count?: number | null;
        total_reading_time?: number | null;
        total_votes?: number | null;
        updated_at?: any | null;
        upvote_count?: number | null;
        user_id: any;
        vote_accuracy?: any | null;
        xp_to_next_level?: number | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneUserProfileVariables = Exact<{
  _inc?: InputMaybe<UserProfilesIncInput>;
  _set?: InputMaybe<UserProfilesSetInput>;
  pk_columns: UserProfilesPkColumnsInput;
}>;

export type UpdateOneUserProfileResponse = {
  __typename?: "mutation_root";
  update_user_profiles_by_pk?: {
    __typename?: "user_profiles";
    avatar?: string | null;
    created_at?: any | null;
    dob?: any | null;
    email: string;
    followed_count?: number | null;
    followers_count?: number | null;
    gender_id?: any | null;
    given_name?: string | null;
    id: any;
    introduction?: string | null;
    is_active?: boolean | null;
    last_seen?: any | null;
    plan?: any | null;
    role: any;
    surname?: string | null;
    updated_at?: any | null;
    username?: string | null;
    addresses: Array<{
      __typename?: "addresses";
      address_type?: any | null;
      city_id: number;
      company_id?: any | null;
      country_id: number;
      created_at?: any | null;
      id: number;
      is_primary?: boolean | null;
      name?: string | null;
      street1: string;
      street2?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    comments: Array<{
      __typename?: "comments";
      content: string;
      content_id: any;
      content_type: any;
      created_at?: any | null;
      id: any;
      parent_comment_id?: any | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    company_employees: Array<{
      __typename?: "company_employees";
      access_level: any;
      company_id?: any | null;
      created_at?: any | null;
      end_date?: any | null;
      id: any;
      job_description?: string | null;
      role: string;
      start_date?: any | null;
      status?: boolean | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    contacts: Array<{
      __typename?: "contacts";
      company_id?: any | null;
      contact_type?: any | null;
      created_at?: any | null;
      email?: string | null;
      id: number;
      is_primary?: boolean | null;
      phone?: string | null;
      privacy_level?: any | null;
      title?: string | null;
      updated_at?: any | null;
      user_id?: any | null;
    }>;
    content_source_visits: Array<{
      __typename?: "content_source_visits";
      content_id: any;
      created_at?: any | null;
      id: any;
      user_id?: any | null;
    }>;
    customer_payments: Array<{
      __typename?: "customer_payments";
      acquirer_data?: any | null;
      amount: any;
      amount_refunded?: any | null;
      amount_transferred?: any | null;
      bank?: string | null;
      captured?: boolean | null;
      created_at?: any | null;
      currency: string;
      description?: string | null;
      error_code?: string | null;
      error_description?: string | null;
      error_reason?: string | null;
      error_source?: string | null;
      error_step?: string | null;
      external_order_id?: string | null;
      external_payment_id: string;
      fee?: any | null;
      id: number;
      international?: boolean | null;
      invoice_id?: string | null;
      method?: string | null;
      notes?: any | null;
      order_id?: string | null;
      payment_provider_id: number;
      refund_status?: string | null;
      status: string;
      subscription_id?: number | null;
      tax?: any | null;
      user_id: any;
      vpa?: string | null;
      wallet?: string | null;
    }>;
    customer_subscriptions: Array<{
      __typename?: "customer_subscriptions";
      auth_attempts?: number | null;
      cancel_at_period_end?: boolean | null;
      cancel_initiated_by?: string | null;
      change_scheduled_at?: any | null;
      charge_at?: any | null;
      created_at?: any | null;
      current_end: any;
      current_start: any;
      customer_notify?: boolean | null;
      end_at?: any | null;
      ended_at?: any | null;
      expire_by?: any | null;
      external_subscription_id: string;
      has_scheduled_changes?: boolean | null;
      id: number;
      notes?: any | null;
      offer_id?: string | null;
      paid_count?: number | null;
      pause_initiated_by?: string | null;
      payment_provider_id: number;
      plan_id: number;
      quantity?: number | null;
      remaining_count?: number | null;
      short_url?: string | null;
      source?: string | null;
      start_at?: any | null;
      status: string;
      total_count?: number | null;
      type?: number | null;
      updated_at?: any | null;
      user_id: any;
    }>;
    feedbacks: Array<{
      __typename?: "feedbacks";
      created_at: any;
      device_info?: string | null;
      feedback_status?: any | null;
      feedback_type?: any | null;
      id: number;
      message: string;
      page_identifier: string;
      rating?: number | null;
      resolution_comment?: string | null;
      updated_at: any;
      user_id?: any | null;
    }>;
    feeds: Array<{
      __typename?: "feeds";
      created_at: any;
      id: any;
      name?: string | null;
      user_id?: any | null;
    }>;
    follows: Array<{
      __typename?: "follows";
      created_at?: any | null;
      followed_entity: any;
      followed_id: any;
      id: any;
      user_id: any;
    }>;
    user_metric?: {
      __typename?: "user_metrics";
      achievements?: any | null;
      best_streak?: number | null;
      created_at?: any | null;
      current_level?: number | null;
      current_streak?: number | null;
      current_xp?: number | null;
      downvote_count?: number | null;
      id: any;
      interaction_stats?: any | null;
      last_vote_date?: any | null;
      multipliers?: any | null;
      points?: number | null;
      points_breakdown?: any | null;
      titles?: any | null;
      today_vote_count?: number | null;
      total_reading_time?: number | null;
      total_votes?: number | null;
      updated_at?: any | null;
      upvote_count?: number | null;
      user_id: any;
      vote_accuracy?: any | null;
      xp_to_next_level?: number | null;
    } | null;
  } | null;
};

export type UpdateManyUserProfilesManyVariables = Exact<{
  updates: Array<UserProfilesUpdates> | UserProfilesUpdates;
}>;

export type UpdateManyUserProfilesManyResponse = {
  __typename?: "mutation_root";
  update_user_profiles_many?: Array<{
    __typename?: "user_profiles_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "user_profiles";
      avatar?: string | null;
      created_at?: any | null;
      dob?: any | null;
      email: string;
      followed_count?: number | null;
      followers_count?: number | null;
      gender_id?: any | null;
      given_name?: string | null;
      id: any;
      introduction?: string | null;
      is_active?: boolean | null;
      last_seen?: any | null;
      plan?: any | null;
      role: any;
      surname?: string | null;
      updated_at?: any | null;
      username?: string | null;
      addresses: Array<{
        __typename?: "addresses";
        address_type?: any | null;
        city_id: number;
        company_id?: any | null;
        country_id: number;
        created_at?: any | null;
        id: number;
        is_primary?: boolean | null;
        name?: string | null;
        street1: string;
        street2?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      comments: Array<{
        __typename?: "comments";
        content: string;
        content_id: any;
        content_type: any;
        created_at?: any | null;
        id: any;
        parent_comment_id?: any | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      company_employees: Array<{
        __typename?: "company_employees";
        access_level: any;
        company_id?: any | null;
        created_at?: any | null;
        end_date?: any | null;
        id: any;
        job_description?: string | null;
        role: string;
        start_date?: any | null;
        status?: boolean | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      contacts: Array<{
        __typename?: "contacts";
        company_id?: any | null;
        contact_type?: any | null;
        created_at?: any | null;
        email?: string | null;
        id: number;
        is_primary?: boolean | null;
        phone?: string | null;
        privacy_level?: any | null;
        title?: string | null;
        updated_at?: any | null;
        user_id?: any | null;
      }>;
      content_source_visits: Array<{
        __typename?: "content_source_visits";
        content_id: any;
        created_at?: any | null;
        id: any;
        user_id?: any | null;
      }>;
      customer_payments: Array<{
        __typename?: "customer_payments";
        acquirer_data?: any | null;
        amount: any;
        amount_refunded?: any | null;
        amount_transferred?: any | null;
        bank?: string | null;
        captured?: boolean | null;
        created_at?: any | null;
        currency: string;
        description?: string | null;
        error_code?: string | null;
        error_description?: string | null;
        error_reason?: string | null;
        error_source?: string | null;
        error_step?: string | null;
        external_order_id?: string | null;
        external_payment_id: string;
        fee?: any | null;
        id: number;
        international?: boolean | null;
        invoice_id?: string | null;
        method?: string | null;
        notes?: any | null;
        order_id?: string | null;
        payment_provider_id: number;
        refund_status?: string | null;
        status: string;
        subscription_id?: number | null;
        tax?: any | null;
        user_id: any;
        vpa?: string | null;
        wallet?: string | null;
      }>;
      customer_subscriptions: Array<{
        __typename?: "customer_subscriptions";
        auth_attempts?: number | null;
        cancel_at_period_end?: boolean | null;
        cancel_initiated_by?: string | null;
        change_scheduled_at?: any | null;
        charge_at?: any | null;
        created_at?: any | null;
        current_end: any;
        current_start: any;
        customer_notify?: boolean | null;
        end_at?: any | null;
        ended_at?: any | null;
        expire_by?: any | null;
        external_subscription_id: string;
        has_scheduled_changes?: boolean | null;
        id: number;
        notes?: any | null;
        offer_id?: string | null;
        paid_count?: number | null;
        pause_initiated_by?: string | null;
        payment_provider_id: number;
        plan_id: number;
        quantity?: number | null;
        remaining_count?: number | null;
        short_url?: string | null;
        source?: string | null;
        start_at?: any | null;
        status: string;
        total_count?: number | null;
        type?: number | null;
        updated_at?: any | null;
        user_id: any;
      }>;
      feedbacks: Array<{
        __typename?: "feedbacks";
        created_at: any;
        device_info?: string | null;
        feedback_status?: any | null;
        feedback_type?: any | null;
        id: number;
        message: string;
        page_identifier: string;
        rating?: number | null;
        resolution_comment?: string | null;
        updated_at: any;
        user_id?: any | null;
      }>;
      feeds: Array<{
        __typename?: "feeds";
        created_at: any;
        id: any;
        name?: string | null;
        user_id?: any | null;
      }>;
      follows: Array<{
        __typename?: "follows";
        created_at?: any | null;
        followed_entity: any;
        followed_id: any;
        id: any;
        user_id: any;
      }>;
      user_metric?: {
        __typename?: "user_metrics";
        achievements?: any | null;
        best_streak?: number | null;
        created_at?: any | null;
        current_level?: number | null;
        current_streak?: number | null;
        current_xp?: number | null;
        downvote_count?: number | null;
        id: any;
        interaction_stats?: any | null;
        last_vote_date?: any | null;
        multipliers?: any | null;
        points?: number | null;
        points_breakdown?: any | null;
        titles?: any | null;
        today_vote_count?: number | null;
        total_reading_time?: number | null;
        total_votes?: number | null;
        updated_at?: any | null;
        upvote_count?: number | null;
        user_id: any;
        vote_accuracy?: any | null;
        xp_to_next_level?: number | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyVoteVariables = Exact<{
  _inc?: InputMaybe<VotesIncInput>;
  _set?: InputMaybe<VotesSetInput>;
  where: VotesBoolExp;
}>;

export type UpdateManyVoteResponse = {
  __typename?: "mutation_root";
  update_votes?: {
    __typename?: "votes_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "votes";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      id: any;
      user_id: any;
      vote_type: any;
    }>;
  } | null;
};

export type UpdateOneVoteVariables = Exact<{
  _inc?: InputMaybe<VotesIncInput>;
  _set?: InputMaybe<VotesSetInput>;
  pk_columns: VotesPkColumnsInput;
}>;

export type UpdateOneVoteResponse = {
  __typename?: "mutation_root";
  update_votes_by_pk?: {
    __typename?: "votes";
    content_id: any;
    content_type: string;
    created_at?: any | null;
    id: any;
    user_id: any;
    vote_type: any;
  } | null;
};

export type UpdateManyVotesManyVariables = Exact<{
  updates: Array<VotesUpdates> | VotesUpdates;
}>;

export type UpdateManyVotesManyResponse = {
  __typename?: "mutation_root";
  update_votes_many?: Array<{
    __typename?: "votes_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "votes";
      content_id: any;
      content_type: string;
      created_at?: any | null;
      id: any;
      user_id: any;
      vote_type: any;
    }>;
  } | null> | null;
};

export type UpdateManyWorkflowVariables = Exact<{
  _append?: InputMaybe<WorkflowsAppendInput>;
  _delete_at_path?: InputMaybe<WorkflowsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<WorkflowsDeleteElemInput>;
  _delete_key?: InputMaybe<WorkflowsDeleteKeyInput>;
  _prepend?: InputMaybe<WorkflowsPrependInput>;
  _set?: InputMaybe<WorkflowsSetInput>;
  where: WorkflowsBoolExp;
}>;

export type UpdateManyWorkflowResponse = {
  __typename?: "mutation_root";
  update_workflows?: {
    __typename?: "workflows_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "workflows";
      completed_at?: any | null;
      created_at?: any | null;
      id: any;
      metadata?: any | null;
      name: string;
      started_at?: any | null;
      status: any;
      updated_at?: any | null;
    }>;
  } | null;
};

export type UpdateOneWorkflowVariables = Exact<{
  _append?: InputMaybe<WorkflowsAppendInput>;
  _delete_at_path?: InputMaybe<WorkflowsDeleteAtPathInput>;
  _delete_elem?: InputMaybe<WorkflowsDeleteElemInput>;
  _delete_key?: InputMaybe<WorkflowsDeleteKeyInput>;
  _prepend?: InputMaybe<WorkflowsPrependInput>;
  _set?: InputMaybe<WorkflowsSetInput>;
  pk_columns: WorkflowsPkColumnsInput;
}>;

export type UpdateOneWorkflowResponse = {
  __typename?: "mutation_root";
  update_workflows_by_pk?: {
    __typename?: "workflows";
    completed_at?: any | null;
    created_at?: any | null;
    id: any;
    metadata?: any | null;
    name: string;
    started_at?: any | null;
    status: any;
    updated_at?: any | null;
  } | null;
};

export type UpdateManyWorkflowsManyVariables = Exact<{
  updates: Array<WorkflowsUpdates> | WorkflowsUpdates;
}>;

export type UpdateManyWorkflowsManyResponse = {
  __typename?: "mutation_root";
  update_workflows_many?: Array<{
    __typename?: "workflows_mutation_response";
    affected_rows: number;
    returning: Array<{
      __typename?: "workflows";
      completed_at?: any | null;
      created_at?: any | null;
      id: any;
      metadata?: any | null;
      name: string;
      started_at?: any | null;
      status: any;
      updated_at?: any | null;
    }>;
  } | null> | null;
};

export class AdDailyMetricsClient extends EntityClient<
  Types.AdDailyMetrics,
  null,
  null,
  Types.AdDailyMetricsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "AdDailyMetrics", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.AdDailyMetrics> = {}) => {
      return this.executeQuery<number>(
        {
          key: "AdDailyMetrics.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.AdDailyMetrics> = {}) => {
      return this.executeQuery<Types.AdDailyMetricsAggregate>(
        {
          key: "AdDailyMetrics.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.AdDailyMetrics> = {}) {
    return this.executeQuery<Types.AdDailyMetrics[]>(
      {
        key: "AdDailyMetrics.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.AdDailyMetrics>) {
    return this.executeQuery<Types.AdDailyMetrics>(
      {
        key: "AdDailyMetrics.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class AdPackagesClient extends EntityClient<
  Types.AdPackages,
  null,
  null,
  Types.AdPackagesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "AdPackages", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.AdPackages> = {}) => {
      return this.executeQuery<number>(
        {
          key: "AdPackages.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.AdPackages> = {}) => {
      return this.executeQuery<Types.AdPackagesAggregate>(
        {
          key: "AdPackages.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.AdPackages> = {}) {
    return this.executeQuery<Types.AdPackages[]>(
      {
        key: "AdPackages.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.AdPackages>) {
    return this.executeQuery<Types.AdPackages>(
      {
        key: "AdPackages.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class AdVariantsClient extends EntityClient<
  Types.AdVariants,
  null,
  null,
  Types.AdVariantsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "AdVariants", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.AdVariants> = {}) => {
      return this.executeQuery<number>(
        {
          key: "AdVariants.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.AdVariants> = {}) => {
      return this.executeQuery<Types.AdVariantsAggregate>(
        {
          key: "AdVariants.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.AdVariants> = {}) {
    return this.executeQuery<Types.AdVariants[]>(
      {
        key: "AdVariants.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.AdVariants>) {
    return this.executeQuery<Types.AdVariants>(
      {
        key: "AdVariants.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class AddressesClient extends EntityClient<
  Types.Addresses,
  null,
  null,
  Types.AddressesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Addresses", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Addresses> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Addresses.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Addresses> = {}) => {
      return this.executeQuery<Types.AddressesAggregate>(
        {
          key: "Addresses.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Addresses> = {}) {
    return this.executeQuery<Types.Addresses[]>(
      {
        key: "Addresses.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Addresses>) {
    return this.executeQuery<Types.Addresses>(
      {
        key: "Addresses.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class AdsClient extends EntityClient<
  Types.Ads,
  null,
  null,
  Types.AdsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Ads", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Ads> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Ads.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Ads> = {}) => {
      return this.executeQuery<Types.AdsAggregate>(
        {
          key: "Ads.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Ads> = {}) {
    return this.executeQuery<Types.Ads[]>(
      {
        key: "Ads.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Ads>) {
    return this.executeQuery<Types.Ads>(
      {
        key: "Ads.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class BlacklistedDomainsClient extends EntityClient<
  Types.BlacklistedDomains,
  null,
  null,
  Types.BlacklistedDomainsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "BlacklistedDomains", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.BlacklistedDomains> = {}) => {
      return this.executeQuery<number>(
        {
          key: "BlacklistedDomains.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.BlacklistedDomains> = {}) => {
      return this.executeQuery<Types.BlacklistedDomainsAggregate>(
        {
          key: "BlacklistedDomains.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.BlacklistedDomains> = {}) {
    return this.executeQuery<Types.BlacklistedDomains[]>(
      {
        key: "BlacklistedDomains.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.BlacklistedDomains>) {
    return this.executeQuery<Types.BlacklistedDomains>(
      {
        key: "BlacklistedDomains.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class BlacklistedUrlsClient extends EntityClient<
  Types.BlacklistedUrls,
  null,
  null,
  Types.BlacklistedUrlsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "BlacklistedUrls", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.BlacklistedUrls> = {}) => {
      return this.executeQuery<number>(
        {
          key: "BlacklistedUrls.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.BlacklistedUrls> = {}) => {
      return this.executeQuery<Types.BlacklistedUrlsAggregate>(
        {
          key: "BlacklistedUrls.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.BlacklistedUrls> = {}) {
    return this.executeQuery<Types.BlacklistedUrls[]>(
      {
        key: "BlacklistedUrls.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.BlacklistedUrls>) {
    return this.executeQuery<Types.BlacklistedUrls>(
      {
        key: "BlacklistedUrls.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class BlockedIpsClient extends EntityClient<
  Types.BlockedIps,
  null,
  null,
  Types.BlockedIpsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "BlockedIps", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.BlockedIps> = {}) => {
      return this.executeQuery<number>(
        {
          key: "BlockedIps.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.BlockedIps> = {}) => {
      return this.executeQuery<Types.BlockedIpsAggregate>(
        {
          key: "BlockedIps.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.BlockedIps> = {}) {
    return this.executeQuery<Types.BlockedIps[]>(
      {
        key: "BlockedIps.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.BlockedIps>) {
    return this.executeQuery<Types.BlockedIps>(
      {
        key: "BlockedIps.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class BookmarkFoldersClient extends EntityClient<
  Types.BookmarkFolders,
  null,
  null,
  Types.BookmarkFoldersBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "BookmarkFolders", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.BookmarkFolders> = {}) => {
      return this.executeQuery<number>(
        {
          key: "BookmarkFolders.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.BookmarkFolders> = {}) => {
      return this.executeQuery<Types.BookmarkFoldersAggregate>(
        {
          key: "BookmarkFolders.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.BookmarkFolders> = {}) {
    return this.executeQuery<Types.BookmarkFolders[]>(
      {
        key: "BookmarkFolders.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.BookmarkFolders>) {
    return this.executeQuery<Types.BookmarkFolders>(
      {
        key: "BookmarkFolders.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class BookmarksClient extends EntityClient<
  Types.Bookmarks,
  null,
  null,
  Types.BookmarksBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Bookmarks", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Bookmarks> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Bookmarks.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Bookmarks> = {}) => {
      return this.executeQuery<Types.BookmarksAggregate>(
        {
          key: "Bookmarks.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Bookmarks> = {}) {
    return this.executeQuery<Types.Bookmarks[]>(
      {
        key: "Bookmarks.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Bookmarks>) {
    return this.executeQuery<Types.Bookmarks>(
      {
        key: "Bookmarks.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class BusinessDomainsClient extends EntityClient<
  Types.BusinessDomains,
  null,
  null,
  Types.BusinessDomainsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "BusinessDomains", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.BusinessDomains> = {}) => {
      return this.executeQuery<number>(
        {
          key: "BusinessDomains.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.BusinessDomains> = {}) => {
      return this.executeQuery<Types.BusinessDomainsAggregate>(
        {
          key: "BusinessDomains.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.BusinessDomains> = {}) {
    return this.executeQuery<Types.BusinessDomains[]>(
      {
        key: "BusinessDomains.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.BusinessDomains>) {
    return this.executeQuery<Types.BusinessDomains>(
      {
        key: "BusinessDomains.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CategoriesClient extends EntityClient<
  Types.Categories,
  null,
  null,
  Types.CategoriesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Categories", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Categories> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Categories.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Categories> = {}) => {
      return this.executeQuery<Types.CategoriesAggregate>(
        {
          key: "Categories.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Categories> = {}) {
    return this.executeQuery<Types.Categories[]>(
      {
        key: "Categories.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Categories>) {
    return this.executeQuery<Types.Categories>(
      {
        key: "Categories.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CategorizedUrlsClient extends EntityClient<
  Types.CategorizedUrls,
  null,
  null,
  Types.CategorizedUrlsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "CategorizedUrls", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.CategorizedUrls> = {}) => {
      return this.executeQuery<number>(
        {
          key: "CategorizedUrls.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.CategorizedUrls> = {}) => {
      return this.executeQuery<Types.CategorizedUrlsAggregate>(
        {
          key: "CategorizedUrls.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.CategorizedUrls> = {}) {
    return this.executeQuery<Types.CategorizedUrls[]>(
      {
        key: "CategorizedUrls.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.CategorizedUrls>) {
    return this.executeQuery<Types.CategorizedUrls>(
      {
        key: "CategorizedUrls.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CircuitBreakerStatesClient extends EntityClient<
  Types.CircuitBreakerStates,
  null,
  null,
  Types.CircuitBreakerStatesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "CircuitBreakerStates", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.CircuitBreakerStates> = {}) => {
      return this.executeQuery<number>(
        {
          key: "CircuitBreakerStates.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.CircuitBreakerStates> = {}) => {
      return this.executeQuery<Types.CircuitBreakerStatesAggregate>(
        {
          key: "CircuitBreakerStates.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.CircuitBreakerStates> = {}) {
    return this.executeQuery<Types.CircuitBreakerStates[]>(
      {
        key: "CircuitBreakerStates.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.CircuitBreakerStates>) {
    return this.executeQuery<Types.CircuitBreakerStates>(
      {
        key: "CircuitBreakerStates.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CitiesClient extends EntityClient<
  Types.Cities,
  null,
  null,
  Types.CitiesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Cities", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Cities> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Cities.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Cities> = {}) => {
      return this.executeQuery<Types.CitiesAggregate>(
        {
          key: "Cities.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Cities> = {}) {
    return this.executeQuery<Types.Cities[]>(
      {
        key: "Cities.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Cities>) {
    return this.executeQuery<Types.Cities>(
      {
        key: "Cities.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CommentsClient extends EntityClient<
  Types.Comments,
  null,
  null,
  Types.CommentsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Comments", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Comments> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Comments.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Comments> = {}) => {
      return this.executeQuery<Types.CommentsAggregate>(
        {
          key: "Comments.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Comments> = {}) {
    return this.executeQuery<Types.Comments[]>(
      {
        key: "Comments.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Comments>) {
    return this.executeQuery<Types.Comments>(
      {
        key: "Comments.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CompaniesClient extends EntityClient<
  Types.Companies,
  null,
  null,
  Types.CompaniesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Companies", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Companies> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Companies.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Companies> = {}) => {
      return this.executeQuery<Types.CompaniesAggregate>(
        {
          key: "Companies.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Companies> = {}) {
    return this.executeQuery<Types.Companies[]>(
      {
        key: "Companies.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Companies>) {
    return this.executeQuery<Types.Companies>(
      {
        key: "Companies.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CompanyContactsClient extends EntityClient<
  Types.CompanyContacts,
  null,
  null,
  Types.CompanyContactsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "CompanyContacts", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.CompanyContacts> = {}) => {
      return this.executeQuery<number>(
        {
          key: "CompanyContacts.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.CompanyContacts> = {}) => {
      return this.executeQuery<Types.CompanyContactsAggregate>(
        {
          key: "CompanyContacts.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.CompanyContacts> = {}) {
    return this.executeQuery<Types.CompanyContacts[]>(
      {
        key: "CompanyContacts.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.CompanyContacts>) {
    return this.executeQuery<Types.CompanyContacts>(
      {
        key: "CompanyContacts.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CompanyEmployeesClient extends EntityClient<
  Types.CompanyEmployees,
  null,
  null,
  Types.CompanyEmployeesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "CompanyEmployees", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.CompanyEmployees> = {}) => {
      return this.executeQuery<number>(
        {
          key: "CompanyEmployees.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.CompanyEmployees> = {}) => {
      return this.executeQuery<Types.CompanyEmployeesAggregate>(
        {
          key: "CompanyEmployees.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.CompanyEmployees> = {}) {
    return this.executeQuery<Types.CompanyEmployees[]>(
      {
        key: "CompanyEmployees.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.CompanyEmployees>) {
    return this.executeQuery<Types.CompanyEmployees>(
      {
        key: "CompanyEmployees.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CompanyExtrasClient extends EntityClient<
  Types.CompanyExtras,
  null,
  null,
  Types.CompanyExtrasBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "CompanyExtras", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.CompanyExtras> = {}) => {
      return this.executeQuery<number>(
        {
          key: "CompanyExtras.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.CompanyExtras> = {}) => {
      return this.executeQuery<Types.CompanyExtrasAggregate>(
        {
          key: "CompanyExtras.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.CompanyExtras> = {}) {
    return this.executeQuery<Types.CompanyExtras[]>(
      {
        key: "CompanyExtras.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.CompanyExtras>) {
    return this.executeQuery<Types.CompanyExtras>(
      {
        key: "CompanyExtras.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CompanyMetricsClient extends EntityClient<
  Types.CompanyMetrics,
  null,
  null,
  Types.CompanyMetricsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "CompanyMetrics", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.CompanyMetrics> = {}) => {
      return this.executeQuery<number>(
        {
          key: "CompanyMetrics.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.CompanyMetrics> = {}) => {
      return this.executeQuery<Types.CompanyMetricsAggregate>(
        {
          key: "CompanyMetrics.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.CompanyMetrics> = {}) {
    return this.executeQuery<Types.CompanyMetrics[]>(
      {
        key: "CompanyMetrics.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.CompanyMetrics>) {
    return this.executeQuery<Types.CompanyMetrics>(
      {
        key: "CompanyMetrics.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ContactsClient extends EntityClient<
  Types.Contacts,
  null,
  null,
  Types.ContactsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Contacts", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Contacts> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Contacts.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Contacts> = {}) => {
      return this.executeQuery<Types.ContactsAggregate>(
        {
          key: "Contacts.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Contacts> = {}) {
    return this.executeQuery<Types.Contacts[]>(
      {
        key: "Contacts.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Contacts>) {
    return this.executeQuery<Types.Contacts>(
      {
        key: "Contacts.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ContentCategoriesClient extends EntityClient<
  Types.ContentCategories,
  null,
  null,
  Types.ContentCategoriesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ContentCategories", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ContentCategories> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ContentCategories.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ContentCategories> = {}) => {
      return this.executeQuery<Types.ContentCategoriesAggregate>(
        {
          key: "ContentCategories.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ContentCategories> = {}) {
    return this.executeQuery<Types.ContentCategories[]>(
      {
        key: "ContentCategories.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ContentCategories>) {
    return this.executeQuery<Types.ContentCategories>(
      {
        key: "ContentCategories.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ContentScoresClient extends EntityClient<
  Types.ContentScores,
  null,
  null,
  Types.ContentScoresBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ContentScores", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ContentScores> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ContentScores.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ContentScores> = {}) => {
      return this.executeQuery<Types.ContentScoresAggregate>(
        {
          key: "ContentScores.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ContentScores> = {}) {
    return this.executeQuery<Types.ContentScores[]>(
      {
        key: "ContentScores.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ContentScores>) {
    return this.executeQuery<Types.ContentScores>(
      {
        key: "ContentScores.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ContentSourceVisitsClient extends EntityClient<
  Types.ContentSourceVisits,
  null,
  null,
  Types.ContentSourceVisitsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ContentSourceVisits", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ContentSourceVisits> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ContentSourceVisits.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ContentSourceVisits> = {}) => {
      return this.executeQuery<Types.ContentSourceVisitsAggregate>(
        {
          key: "ContentSourceVisits.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ContentSourceVisits> = {}) {
    return this.executeQuery<Types.ContentSourceVisits[]>(
      {
        key: "ContentSourceVisits.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ContentSourceVisits>) {
    return this.executeQuery<Types.ContentSourceVisits>(
      {
        key: "ContentSourceVisits.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ContentSourcesClient extends EntityClient<
  Types.ContentSources,
  null,
  null,
  Types.ContentSourcesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ContentSources", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ContentSources> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ContentSources.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ContentSources> = {}) => {
      return this.executeQuery<Types.ContentSourcesAggregate>(
        {
          key: "ContentSources.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ContentSources> = {}) {
    return this.executeQuery<Types.ContentSources[]>(
      {
        key: "ContentSources.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ContentSources>) {
    return this.executeQuery<Types.ContentSources>(
      {
        key: "ContentSources.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ContentStatusesClient extends EntityClient<
  Types.ContentStatuses,
  null,
  null,
  Types.ContentStatusesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ContentStatuses", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ContentStatuses> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ContentStatuses.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ContentStatuses> = {}) => {
      return this.executeQuery<Types.ContentStatusesAggregate>(
        {
          key: "ContentStatuses.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ContentStatuses> = {}) {
    return this.executeQuery<Types.ContentStatuses[]>(
      {
        key: "ContentStatuses.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ContentStatuses>) {
    return this.executeQuery<Types.ContentStatuses>(
      {
        key: "ContentStatuses.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ContentTagsClient extends EntityClient<
  Types.ContentTags,
  null,
  null,
  Types.ContentTagsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ContentTags", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ContentTags> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ContentTags.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ContentTags> = {}) => {
      return this.executeQuery<Types.ContentTagsAggregate>(
        {
          key: "ContentTags.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ContentTags> = {}) {
    return this.executeQuery<Types.ContentTags[]>(
      {
        key: "ContentTags.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ContentTags>) {
    return this.executeQuery<Types.ContentTags>(
      {
        key: "ContentTags.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ContentsClient extends EntityClient<
  Types.Contents,
  null,
  null,
  Types.ContentsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Contents", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Contents> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Contents.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Contents> = {}) => {
      return this.executeQuery<Types.ContentsAggregate>(
        {
          key: "Contents.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Contents> = {}) {
    return this.executeQuery<Types.Contents[]>(
      {
        key: "Contents.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Contents>) {
    return this.executeQuery<Types.Contents>(
      {
        key: "Contents.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CountriesClient extends EntityClient<
  Types.Countries,
  null,
  null,
  Types.CountriesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Countries", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Countries> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Countries.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Countries> = {}) => {
      return this.executeQuery<Types.CountriesAggregate>(
        {
          key: "Countries.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Countries> = {}) {
    return this.executeQuery<Types.Countries[]>(
      {
        key: "Countries.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Countries>) {
    return this.executeQuery<Types.Countries>(
      {
        key: "Countries.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CustomerPaymentsClient extends EntityClient<
  Types.CustomerPayments,
  null,
  null,
  Types.CustomerPaymentsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "CustomerPayments", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.CustomerPayments> = {}) => {
      return this.executeQuery<number>(
        {
          key: "CustomerPayments.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.CustomerPayments> = {}) => {
      return this.executeQuery<Types.CustomerPaymentsAggregate>(
        {
          key: "CustomerPayments.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.CustomerPayments> = {}) {
    return this.executeQuery<Types.CustomerPayments[]>(
      {
        key: "CustomerPayments.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.CustomerPayments>) {
    return this.executeQuery<Types.CustomerPayments>(
      {
        key: "CustomerPayments.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CustomerProcessedWebhooksClient extends EntityClient<
  Types.CustomerProcessedWebhooks,
  null,
  null,
  Types.CustomerProcessedWebhooksBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "CustomerProcessedWebhooks", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.CustomerProcessedWebhooks> = {}) => {
      return this.executeQuery<number>(
        {
          key: "CustomerProcessedWebhooks.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.CustomerProcessedWebhooks> = {}) => {
      return this.executeQuery<Types.CustomerProcessedWebhooksAggregate>(
        {
          key: "CustomerProcessedWebhooks.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.CustomerProcessedWebhooks> = {}) {
    return this.executeQuery<Types.CustomerProcessedWebhooks[]>(
      {
        key: "CustomerProcessedWebhooks.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.CustomerProcessedWebhooks>) {
    return this.executeQuery<Types.CustomerProcessedWebhooks>(
      {
        key: "CustomerProcessedWebhooks.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CustomerRefundsClient extends EntityClient<
  Types.CustomerRefunds,
  null,
  null,
  Types.CustomerRefundsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "CustomerRefunds", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.CustomerRefunds> = {}) => {
      return this.executeQuery<number>(
        {
          key: "CustomerRefunds.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.CustomerRefunds> = {}) => {
      return this.executeQuery<Types.CustomerRefundsAggregate>(
        {
          key: "CustomerRefunds.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.CustomerRefunds> = {}) {
    return this.executeQuery<Types.CustomerRefunds[]>(
      {
        key: "CustomerRefunds.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.CustomerRefunds>) {
    return this.executeQuery<Types.CustomerRefunds>(
      {
        key: "CustomerRefunds.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CustomerSubscriptionPlansClient extends EntityClient<
  Types.CustomerSubscriptionPlans,
  null,
  null,
  Types.CustomerSubscriptionPlansBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "CustomerSubscriptionPlans", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.CustomerSubscriptionPlans> = {}) => {
      return this.executeQuery<number>(
        {
          key: "CustomerSubscriptionPlans.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.CustomerSubscriptionPlans> = {}) => {
      return this.executeQuery<Types.CustomerSubscriptionPlansAggregate>(
        {
          key: "CustomerSubscriptionPlans.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.CustomerSubscriptionPlans> = {}) {
    return this.executeQuery<Types.CustomerSubscriptionPlans[]>(
      {
        key: "CustomerSubscriptionPlans.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.CustomerSubscriptionPlans>) {
    return this.executeQuery<Types.CustomerSubscriptionPlans>(
      {
        key: "CustomerSubscriptionPlans.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class CustomerSubscriptionsClient extends EntityClient<
  Types.CustomerSubscriptions,
  null,
  null,
  Types.CustomerSubscriptionsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "CustomerSubscriptions", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.CustomerSubscriptions> = {}) => {
      return this.executeQuery<number>(
        {
          key: "CustomerSubscriptions.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.CustomerSubscriptions> = {}) => {
      return this.executeQuery<Types.CustomerSubscriptionsAggregate>(
        {
          key: "CustomerSubscriptions.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.CustomerSubscriptions> = {}) {
    return this.executeQuery<Types.CustomerSubscriptions[]>(
      {
        key: "CustomerSubscriptions.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.CustomerSubscriptions>) {
    return this.executeQuery<Types.CustomerSubscriptions>(
      {
        key: "CustomerSubscriptions.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class EmbeddingReviewsClient extends EntityClient<
  Types.EmbeddingReviews,
  null,
  null,
  Types.EmbeddingReviewsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "EmbeddingReviews", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.EmbeddingReviews> = {}) => {
      return this.executeQuery<number>(
        {
          key: "EmbeddingReviews.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.EmbeddingReviews> = {}) => {
      return this.executeQuery<Types.EmbeddingReviewsAggregate>(
        {
          key: "EmbeddingReviews.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.EmbeddingReviews> = {}) {
    return this.executeQuery<Types.EmbeddingReviews[]>(
      {
        key: "EmbeddingReviews.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.EmbeddingReviews>) {
    return this.executeQuery<Types.EmbeddingReviews>(
      {
        key: "EmbeddingReviews.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ErrorCorrelationsClient extends EntityClient<
  Types.ErrorCorrelations,
  null,
  null,
  Types.ErrorCorrelationsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ErrorCorrelations", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ErrorCorrelations> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ErrorCorrelations.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ErrorCorrelations> = {}) => {
      return this.executeQuery<Types.ErrorCorrelationsAggregate>(
        {
          key: "ErrorCorrelations.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ErrorCorrelations> = {}) {
    return this.executeQuery<Types.ErrorCorrelations[]>(
      {
        key: "ErrorCorrelations.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ErrorCorrelations>) {
    return this.executeQuery<Types.ErrorCorrelations>(
      {
        key: "ErrorCorrelations.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ErrorFrequencyClient extends EntityClient<
  Types.ErrorFrequency,
  null,
  null,
  Types.ErrorFrequencyBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ErrorFrequency", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ErrorFrequency> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ErrorFrequency.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ErrorFrequency> = {}) => {
      return this.executeQuery<Types.ErrorFrequencyAggregate>(
        {
          key: "ErrorFrequency.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ErrorFrequency> = {}) {
    return this.executeQuery<Types.ErrorFrequency[]>(
      {
        key: "ErrorFrequency.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ErrorFrequency>) {
    return this.executeQuery<Types.ErrorFrequency>(
      {
        key: "ErrorFrequency.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ErrorLogsClient extends EntityClient<
  Types.ErrorLogs,
  null,
  null,
  Types.ErrorLogsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ErrorLogs", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ErrorLogs> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ErrorLogs.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ErrorLogs> = {}) => {
      return this.executeQuery<Types.ErrorLogsAggregate>(
        {
          key: "ErrorLogs.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ErrorLogs> = {}) {
    return this.executeQuery<Types.ErrorLogs[]>(
      {
        key: "ErrorLogs.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ErrorLogs>) {
    return this.executeQuery<Types.ErrorLogs>(
      {
        key: "ErrorLogs.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ErrorMetricsClient extends EntityClient<
  Types.ErrorMetrics,
  null,
  null,
  Types.ErrorMetricsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ErrorMetrics", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ErrorMetrics> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ErrorMetrics.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ErrorMetrics> = {}) => {
      return this.executeQuery<Types.ErrorMetricsAggregate>(
        {
          key: "ErrorMetrics.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ErrorMetrics> = {}) {
    return this.executeQuery<Types.ErrorMetrics[]>(
      {
        key: "ErrorMetrics.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ErrorMetrics>) {
    return this.executeQuery<Types.ErrorMetrics>(
      {
        key: "ErrorMetrics.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ErrorPatternsClient extends EntityClient<
  Types.ErrorPatterns,
  null,
  null,
  Types.ErrorPatternsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ErrorPatterns", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ErrorPatterns> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ErrorPatterns.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ErrorPatterns> = {}) => {
      return this.executeQuery<Types.ErrorPatternsAggregate>(
        {
          key: "ErrorPatterns.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ErrorPatterns> = {}) {
    return this.executeQuery<Types.ErrorPatterns[]>(
      {
        key: "ErrorPatterns.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ErrorPatterns>) {
    return this.executeQuery<Types.ErrorPatterns>(
      {
        key: "ErrorPatterns.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ErrorStatsClient extends EntityClient<
  Types.ErrorStats,
  null,
  null,
  Types.ErrorStatsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ErrorStats", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ErrorStats> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ErrorStats.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ErrorStats> = {}) => {
      return this.executeQuery<Types.ErrorStatsAggregate>(
        {
          key: "ErrorStats.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ErrorStats> = {}) {
    return this.executeQuery<Types.ErrorStats[]>(
      {
        key: "ErrorStats.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ErrorStats>) {
    return this.executeQuery<Types.ErrorStats>(
      {
        key: "ErrorStats.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class FeatureRequestsClient extends EntityClient<
  Types.FeatureRequests,
  null,
  null,
  Types.FeatureRequestsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "FeatureRequests", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.FeatureRequests> = {}) => {
      return this.executeQuery<number>(
        {
          key: "FeatureRequests.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.FeatureRequests> = {}) => {
      return this.executeQuery<Types.FeatureRequestsAggregate>(
        {
          key: "FeatureRequests.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.FeatureRequests> = {}) {
    return this.executeQuery<Types.FeatureRequests[]>(
      {
        key: "FeatureRequests.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.FeatureRequests>) {
    return this.executeQuery<Types.FeatureRequests>(
      {
        key: "FeatureRequests.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class FeatureVotesClient extends EntityClient<
  Types.FeatureVotes,
  null,
  null,
  Types.FeatureVotesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "FeatureVotes", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.FeatureVotes> = {}) => {
      return this.executeQuery<number>(
        {
          key: "FeatureVotes.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.FeatureVotes> = {}) => {
      return this.executeQuery<Types.FeatureVotesAggregate>(
        {
          key: "FeatureVotes.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.FeatureVotes> = {}) {
    return this.executeQuery<Types.FeatureVotes[]>(
      {
        key: "FeatureVotes.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.FeatureVotes>) {
    return this.executeQuery<Types.FeatureVotes>(
      {
        key: "FeatureVotes.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class FeedCategoriesClient extends EntityClient<
  Types.FeedCategories,
  null,
  null,
  Types.FeedCategoriesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "FeedCategories", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.FeedCategories> = {}) => {
      return this.executeQuery<number>(
        {
          key: "FeedCategories.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.FeedCategories> = {}) => {
      return this.executeQuery<Types.FeedCategoriesAggregate>(
        {
          key: "FeedCategories.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.FeedCategories> = {}) {
    return this.executeQuery<Types.FeedCategories[]>(
      {
        key: "FeedCategories.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.FeedCategories>) {
    return this.executeQuery<Types.FeedCategories>(
      {
        key: "FeedCategories.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class FeedSourcesClient extends EntityClient<
  Types.FeedSources,
  null,
  null,
  Types.FeedSourcesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "FeedSources", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.FeedSources> = {}) => {
      return this.executeQuery<number>(
        {
          key: "FeedSources.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.FeedSources> = {}) => {
      return this.executeQuery<Types.FeedSourcesAggregate>(
        {
          key: "FeedSources.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.FeedSources> = {}) {
    return this.executeQuery<Types.FeedSources[]>(
      {
        key: "FeedSources.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.FeedSources>) {
    return this.executeQuery<Types.FeedSources>(
      {
        key: "FeedSources.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class FeedbacksClient extends EntityClient<
  Types.Feedbacks,
  null,
  null,
  Types.FeedbacksBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Feedbacks", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Feedbacks> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Feedbacks.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Feedbacks> = {}) => {
      return this.executeQuery<Types.FeedbacksAggregate>(
        {
          key: "Feedbacks.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Feedbacks> = {}) {
    return this.executeQuery<Types.Feedbacks[]>(
      {
        key: "Feedbacks.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Feedbacks>) {
    return this.executeQuery<Types.Feedbacks>(
      {
        key: "Feedbacks.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class FeedsClient extends EntityClient<
  Types.Feeds,
  null,
  null,
  Types.FeedsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Feeds", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Feeds> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Feeds.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Feeds> = {}) => {
      return this.executeQuery<Types.FeedsAggregate>(
        {
          key: "Feeds.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Feeds> = {}) {
    return this.executeQuery<Types.Feeds[]>(
      {
        key: "Feeds.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Feeds>) {
    return this.executeQuery<Types.Feeds>(
      {
        key: "Feeds.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class FollowsClient extends EntityClient<
  Types.Follows,
  null,
  null,
  Types.FollowsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Follows", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Follows> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Follows.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Follows> = {}) => {
      return this.executeQuery<Types.FollowsAggregate>(
        {
          key: "Follows.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Follows> = {}) {
    return this.executeQuery<Types.Follows[]>(
      {
        key: "Follows.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Follows>) {
    return this.executeQuery<Types.Follows>(
      {
        key: "Follows.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class MetricDefinitionsClient extends EntityClient<
  Types.MetricDefinitions,
  null,
  null,
  Types.MetricDefinitionsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "MetricDefinitions", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.MetricDefinitions> = {}) => {
      return this.executeQuery<number>(
        {
          key: "MetricDefinitions.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.MetricDefinitions> = {}) => {
      return this.executeQuery<Types.MetricDefinitionsAggregate>(
        {
          key: "MetricDefinitions.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.MetricDefinitions> = {}) {
    return this.executeQuery<Types.MetricDefinitions[]>(
      {
        key: "MetricDefinitions.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.MetricDefinitions>) {
    return this.executeQuery<Types.MetricDefinitions>(
      {
        key: "MetricDefinitions.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class NewsClient extends EntityClient<
  Types.News,
  null,
  null,
  Types.NewsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "News", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.News> = {}) => {
      return this.executeQuery<number>(
        {
          key: "News.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.News> = {}) => {
      return this.executeQuery<Types.NewsAggregate>(
        {
          key: "News.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.News> = {}) {
    return this.executeQuery<Types.News[]>(
      {
        key: "News.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.News>) {
    return this.executeQuery<Types.News>(
      {
        key: "News.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class NewsDetailsClient extends EntityClient<
  Types.NewsDetails,
  null,
  null,
  Types.NewsDetailsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "NewsDetails", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.NewsDetails> = {}) => {
      return this.executeQuery<number>(
        {
          key: "NewsDetails.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.NewsDetails> = {}) => {
      return this.executeQuery<Types.NewsDetailsAggregate>(
        {
          key: "NewsDetails.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.NewsDetails> = {}) {
    return this.executeQuery<Types.NewsDetails[]>(
      {
        key: "NewsDetails.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.NewsDetails>) {
    return this.executeQuery<Types.NewsDetails>(
      {
        key: "NewsDetails.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class NewsSummariesClient extends EntityClient<
  Types.NewsSummaries,
  null,
  null,
  Types.NewsSummariesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "NewsSummaries", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.NewsSummaries> = {}) => {
      return this.executeQuery<number>(
        {
          key: "NewsSummaries.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.NewsSummaries> = {}) => {
      return this.executeQuery<Types.NewsSummariesAggregate>(
        {
          key: "NewsSummaries.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.NewsSummaries> = {}) {
    return this.executeQuery<Types.NewsSummaries[]>(
      {
        key: "NewsSummaries.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.NewsSummaries>) {
    return this.executeQuery<Types.NewsSummaries>(
      {
        key: "NewsSummaries.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class NewsTagsClient extends EntityClient<
  Types.NewsTags,
  null,
  null,
  Types.NewsTagsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "NewsTags", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.NewsTags> = {}) => {
      return this.executeQuery<number>(
        {
          key: "NewsTags.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.NewsTags> = {}) => {
      return this.executeQuery<Types.NewsTagsAggregate>(
        {
          key: "NewsTags.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.NewsTags> = {}) {
    return this.executeQuery<Types.NewsTags[]>(
      {
        key: "NewsTags.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.NewsTags>) {
    return this.executeQuery<Types.NewsTags>(
      {
        key: "NewsTags.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class NewslettersClient extends EntityClient<
  Types.Newsletters,
  null,
  null,
  Types.NewslettersBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Newsletters", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Newsletters> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Newsletters.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Newsletters> = {}) => {
      return this.executeQuery<Types.NewslettersAggregate>(
        {
          key: "Newsletters.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Newsletters> = {}) {
    return this.executeQuery<Types.Newsletters[]>(
      {
        key: "Newsletters.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Newsletters>) {
    return this.executeQuery<Types.Newsletters>(
      {
        key: "Newsletters.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class PaymentProvidersClient extends EntityClient<
  Types.PaymentProviders,
  null,
  null,
  Types.PaymentProvidersBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "PaymentProviders", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.PaymentProviders> = {}) => {
      return this.executeQuery<number>(
        {
          key: "PaymentProviders.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.PaymentProviders> = {}) => {
      return this.executeQuery<Types.PaymentProvidersAggregate>(
        {
          key: "PaymentProviders.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.PaymentProviders> = {}) {
    return this.executeQuery<Types.PaymentProviders[]>(
      {
        key: "PaymentProviders.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.PaymentProviders>) {
    return this.executeQuery<Types.PaymentProviders>(
      {
        key: "PaymentProviders.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class PlanPermissionsClient extends EntityClient<
  Types.PlanPermissions,
  null,
  null,
  Types.PlanPermissionsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "PlanPermissions", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.PlanPermissions> = {}) => {
      return this.executeQuery<number>(
        {
          key: "PlanPermissions.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.PlanPermissions> = {}) => {
      return this.executeQuery<Types.PlanPermissionsAggregate>(
        {
          key: "PlanPermissions.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.PlanPermissions> = {}) {
    return this.executeQuery<Types.PlanPermissions[]>(
      {
        key: "PlanPermissions.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.PlanPermissions>) {
    return this.executeQuery<Types.PlanPermissions>(
      {
        key: "PlanPermissions.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class RecentErrorsClient extends EntityClient<
  Types.RecentErrors,
  null,
  null,
  Types.RecentErrorsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "RecentErrors", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.RecentErrors> = {}) => {
      return this.executeQuery<number>(
        {
          key: "RecentErrors.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.RecentErrors> = {}) => {
      return this.executeQuery<Types.RecentErrorsAggregate>(
        {
          key: "RecentErrors.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.RecentErrors> = {}) {
    return this.executeQuery<Types.RecentErrors[]>(
      {
        key: "RecentErrors.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.RecentErrors>) {
    return this.executeQuery<Types.RecentErrors>(
      {
        key: "RecentErrors.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ReferralStatsClient extends EntityClient<
  Types.ReferralStats,
  null,
  null,
  Types.ReferralStatsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ReferralStats", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ReferralStats> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ReferralStats.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ReferralStats> = {}) => {
      return this.executeQuery<Types.ReferralStatsAggregate>(
        {
          key: "ReferralStats.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ReferralStats> = {}) {
    return this.executeQuery<Types.ReferralStats[]>(
      {
        key: "ReferralStats.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ReferralStats>) {
    return this.executeQuery<Types.ReferralStats>(
      {
        key: "ReferralStats.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ReferralsClient extends EntityClient<
  Types.Referrals,
  null,
  null,
  Types.ReferralsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Referrals", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Referrals> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Referrals.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Referrals> = {}) => {
      return this.executeQuery<Types.ReferralsAggregate>(
        {
          key: "Referrals.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Referrals> = {}) {
    return this.executeQuery<Types.Referrals[]>(
      {
        key: "Referrals.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Referrals>) {
    return this.executeQuery<Types.Referrals>(
      {
        key: "Referrals.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ReferrerBlocksClient extends EntityClient<
  Types.ReferrerBlocks,
  null,
  null,
  Types.ReferrerBlocksBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ReferrerBlocks", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ReferrerBlocks> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ReferrerBlocks.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ReferrerBlocks> = {}) => {
      return this.executeQuery<Types.ReferrerBlocksAggregate>(
        {
          key: "ReferrerBlocks.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ReferrerBlocks> = {}) {
    return this.executeQuery<Types.ReferrerBlocks[]>(
      {
        key: "ReferrerBlocks.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ReferrerBlocks>) {
    return this.executeQuery<Types.ReferrerBlocks>(
      {
        key: "ReferrerBlocks.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ReferrerRiskMetricsClient extends EntityClient<
  Types.ReferrerRiskMetrics,
  null,
  null,
  Types.ReferrerRiskMetricsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ReferrerRiskMetrics", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ReferrerRiskMetrics> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ReferrerRiskMetrics.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ReferrerRiskMetrics> = {}) => {
      return this.executeQuery<Types.ReferrerRiskMetricsAggregate>(
        {
          key: "ReferrerRiskMetrics.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ReferrerRiskMetrics> = {}) {
    return this.executeQuery<Types.ReferrerRiskMetrics[]>(
      {
        key: "ReferrerRiskMetrics.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ReferrerRiskMetrics>) {
    return this.executeQuery<Types.ReferrerRiskMetrics>(
      {
        key: "ReferrerRiskMetrics.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ResearchClient extends EntityClient<
  Types.Research,
  null,
  null,
  Types.ResearchBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Research", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Research> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Research.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Research> = {}) => {
      return this.executeQuery<Types.ResearchAggregate>(
        {
          key: "Research.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Research> = {}) {
    return this.executeQuery<Types.Research[]>(
      {
        key: "Research.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Research>) {
    return this.executeQuery<Types.Research>(
      {
        key: "Research.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ResearchEmbeddingsClient extends EntityClient<
  Types.ResearchEmbeddings,
  null,
  null,
  Types.ResearchEmbeddingsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ResearchEmbeddings", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ResearchEmbeddings> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ResearchEmbeddings.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ResearchEmbeddings> = {}) => {
      return this.executeQuery<Types.ResearchEmbeddingsAggregate>(
        {
          key: "ResearchEmbeddings.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ResearchEmbeddings> = {}) {
    return this.executeQuery<Types.ResearchEmbeddings[]>(
      {
        key: "ResearchEmbeddings.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ResearchEmbeddings>) {
    return this.executeQuery<Types.ResearchEmbeddings>(
      {
        key: "ResearchEmbeddings.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ResponsesClient extends EntityClient<
  Types.Responses,
  null,
  null,
  Types.ResponsesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Responses", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Responses> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Responses.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Responses> = {}) => {
      return this.executeQuery<Types.ResponsesAggregate>(
        {
          key: "Responses.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Responses> = {}) {
    return this.executeQuery<Types.Responses[]>(
      {
        key: "Responses.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Responses>) {
    return this.executeQuery<Types.Responses>(
      {
        key: "Responses.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class RoleHierarchyClient extends EntityClient<
  Types.RoleHierarchy,
  null,
  null,
  Types.RoleHierarchyBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "RoleHierarchy", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.RoleHierarchy> = {}) => {
      return this.executeQuery<number>(
        {
          key: "RoleHierarchy.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.RoleHierarchy> = {}) => {
      return this.executeQuery<Types.RoleHierarchyAggregate>(
        {
          key: "RoleHierarchy.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.RoleHierarchy> = {}) {
    return this.executeQuery<Types.RoleHierarchy[]>(
      {
        key: "RoleHierarchy.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.RoleHierarchy>) {
    return this.executeQuery<Types.RoleHierarchy>(
      {
        key: "RoleHierarchy.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class RolePermissionsClient extends EntityClient<
  Types.RolePermissions,
  null,
  null,
  Types.RolePermissionsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "RolePermissions", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.RolePermissions> = {}) => {
      return this.executeQuery<number>(
        {
          key: "RolePermissions.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.RolePermissions> = {}) => {
      return this.executeQuery<Types.RolePermissionsAggregate>(
        {
          key: "RolePermissions.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.RolePermissions> = {}) {
    return this.executeQuery<Types.RolePermissions[]>(
      {
        key: "RolePermissions.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.RolePermissions>) {
    return this.executeQuery<Types.RolePermissions>(
      {
        key: "RolePermissions.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class RolePermissionsMaterializedClient extends EntityClient<
  Types.RolePermissionsMaterialized,
  null,
  null,
  Types.RolePermissionsMaterializedBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "RolePermissionsMaterialized", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (
      args: FindManyArgs<Types.RolePermissionsMaterialized> = {},
    ) => {
      return this.executeQuery<number>(
        {
          key: "RolePermissionsMaterialized.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (
      args: FindManyArgs<Types.RolePermissionsMaterialized> = {},
    ) => {
      return this.executeQuery<Types.RolePermissionsMaterializedAggregate>(
        {
          key: "RolePermissionsMaterialized.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.RolePermissionsMaterialized> = {}) {
    return this.executeQuery<Types.RolePermissionsMaterialized[]>(
      {
        key: "RolePermissionsMaterialized.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.RolePermissionsMaterialized>) {
    return this.executeQuery<Types.RolePermissionsMaterialized>(
      {
        key: "RolePermissionsMaterialized.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class ScoringWeightsClient extends EntityClient<
  Types.ScoringWeights,
  null,
  null,
  Types.ScoringWeightsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "ScoringWeights", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.ScoringWeights> = {}) => {
      return this.executeQuery<number>(
        {
          key: "ScoringWeights.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.ScoringWeights> = {}) => {
      return this.executeQuery<Types.ScoringWeightsAggregate>(
        {
          key: "ScoringWeights.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.ScoringWeights> = {}) {
    return this.executeQuery<Types.ScoringWeights[]>(
      {
        key: "ScoringWeights.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.ScoringWeights>) {
    return this.executeQuery<Types.ScoringWeights>(
      {
        key: "ScoringWeights.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class SearchesClient extends EntityClient<
  Types.Searches,
  null,
  null,
  Types.SearchesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Searches", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Searches> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Searches.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Searches> = {}) => {
      return this.executeQuery<Types.SearchesAggregate>(
        {
          key: "Searches.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Searches> = {}) {
    return this.executeQuery<Types.Searches[]>(
      {
        key: "Searches.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Searches>) {
    return this.executeQuery<Types.Searches>(
      {
        key: "Searches.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class SecurityMetricsClient extends EntityClient<
  Types.SecurityMetrics,
  null,
  null,
  Types.SecurityMetricsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "SecurityMetrics", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.SecurityMetrics> = {}) => {
      return this.executeQuery<number>(
        {
          key: "SecurityMetrics.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.SecurityMetrics> = {}) => {
      return this.executeQuery<Types.SecurityMetricsAggregate>(
        {
          key: "SecurityMetrics.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.SecurityMetrics> = {}) {
    return this.executeQuery<Types.SecurityMetrics[]>(
      {
        key: "SecurityMetrics.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.SecurityMetrics>) {
    return this.executeQuery<Types.SecurityMetrics>(
      {
        key: "SecurityMetrics.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class SlowQueryPatternsClient extends EntityClient<
  Types.SlowQueryPatterns,
  null,
  null,
  Types.SlowQueryPatternsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "SlowQueryPatterns", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.SlowQueryPatterns> = {}) => {
      return this.executeQuery<number>(
        {
          key: "SlowQueryPatterns.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.SlowQueryPatterns> = {}) => {
      return this.executeQuery<Types.SlowQueryPatternsAggregate>(
        {
          key: "SlowQueryPatterns.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.SlowQueryPatterns> = {}) {
    return this.executeQuery<Types.SlowQueryPatterns[]>(
      {
        key: "SlowQueryPatterns.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.SlowQueryPatterns>) {
    return this.executeQuery<Types.SlowQueryPatterns>(
      {
        key: "SlowQueryPatterns.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class SocialMediaClient extends EntityClient<
  Types.SocialMedia,
  null,
  null,
  Types.SocialMediaBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "SocialMedia", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.SocialMedia> = {}) => {
      return this.executeQuery<number>(
        {
          key: "SocialMedia.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.SocialMedia> = {}) => {
      return this.executeQuery<Types.SocialMediaAggregate>(
        {
          key: "SocialMedia.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.SocialMedia> = {}) {
    return this.executeQuery<Types.SocialMedia[]>(
      {
        key: "SocialMedia.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.SocialMedia>) {
    return this.executeQuery<Types.SocialMedia>(
      {
        key: "SocialMedia.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class SpiderMetricsClient extends EntityClient<
  Types.SpiderMetrics,
  null,
  null,
  Types.SpiderMetricsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "SpiderMetrics", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.SpiderMetrics> = {}) => {
      return this.executeQuery<number>(
        {
          key: "SpiderMetrics.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.SpiderMetrics> = {}) => {
      return this.executeQuery<Types.SpiderMetricsAggregate>(
        {
          key: "SpiderMetrics.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.SpiderMetrics> = {}) {
    return this.executeQuery<Types.SpiderMetrics[]>(
      {
        key: "SpiderMetrics.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.SpiderMetrics>) {
    return this.executeQuery<Types.SpiderMetrics>(
      {
        key: "SpiderMetrics.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class StrapiMigrationsClient extends EntityClient<
  Types.StrapiMigrations,
  null,
  null,
  Types.StrapiMigrationsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "StrapiMigrations", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.StrapiMigrations> = {}) => {
      return this.executeQuery<number>(
        {
          key: "StrapiMigrations.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.StrapiMigrations> = {}) => {
      return this.executeQuery<Types.StrapiMigrationsAggregate>(
        {
          key: "StrapiMigrations.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.StrapiMigrations> = {}) {
    return this.executeQuery<Types.StrapiMigrations[]>(
      {
        key: "StrapiMigrations.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.StrapiMigrations>) {
    return this.executeQuery<Types.StrapiMigrations>(
      {
        key: "StrapiMigrations.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class StrapiMigrationsInternalClient extends EntityClient<
  Types.StrapiMigrationsInternal,
  null,
  null,
  Types.StrapiMigrationsInternalBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "StrapiMigrationsInternal", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.StrapiMigrationsInternal> = {}) => {
      return this.executeQuery<number>(
        {
          key: "StrapiMigrationsInternal.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.StrapiMigrationsInternal> = {}) => {
      return this.executeQuery<Types.StrapiMigrationsInternalAggregate>(
        {
          key: "StrapiMigrationsInternal.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.StrapiMigrationsInternal> = {}) {
    return this.executeQuery<Types.StrapiMigrationsInternal[]>(
      {
        key: "StrapiMigrationsInternal.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.StrapiMigrationsInternal>) {
    return this.executeQuery<Types.StrapiMigrationsInternal>(
      {
        key: "StrapiMigrationsInternal.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class TableMaintenanceLogClient extends EntityClient<
  Types.TableMaintenanceLog,
  null,
  null,
  Types.TableMaintenanceLogBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "TableMaintenanceLog", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.TableMaintenanceLog> = {}) => {
      return this.executeQuery<number>(
        {
          key: "TableMaintenanceLog.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.TableMaintenanceLog> = {}) => {
      return this.executeQuery<Types.TableMaintenanceLogAggregate>(
        {
          key: "TableMaintenanceLog.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.TableMaintenanceLog> = {}) {
    return this.executeQuery<Types.TableMaintenanceLog[]>(
      {
        key: "TableMaintenanceLog.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.TableMaintenanceLog>) {
    return this.executeQuery<Types.TableMaintenanceLog>(
      {
        key: "TableMaintenanceLog.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class TableQueryPerformanceClient extends EntityClient<
  Types.TableQueryPerformance,
  null,
  null,
  Types.TableQueryPerformanceBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "TableQueryPerformance", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.TableQueryPerformance> = {}) => {
      return this.executeQuery<number>(
        {
          key: "TableQueryPerformance.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.TableQueryPerformance> = {}) => {
      return this.executeQuery<Types.TableQueryPerformanceAggregate>(
        {
          key: "TableQueryPerformance.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.TableQueryPerformance> = {}) {
    return this.executeQuery<Types.TableQueryPerformance[]>(
      {
        key: "TableQueryPerformance.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.TableQueryPerformance>) {
    return this.executeQuery<Types.TableQueryPerformance>(
      {
        key: "TableQueryPerformance.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class TableSequenceUsageClient extends EntityClient<
  Types.TableSequenceUsage,
  null,
  null,
  Types.TableSequenceUsageBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "TableSequenceUsage", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.TableSequenceUsage> = {}) => {
      return this.executeQuery<number>(
        {
          key: "TableSequenceUsage.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.TableSequenceUsage> = {}) => {
      return this.executeQuery<Types.TableSequenceUsageAggregate>(
        {
          key: "TableSequenceUsage.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.TableSequenceUsage> = {}) {
    return this.executeQuery<Types.TableSequenceUsage[]>(
      {
        key: "TableSequenceUsage.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.TableSequenceUsage>) {
    return this.executeQuery<Types.TableSequenceUsage>(
      {
        key: "TableSequenceUsage.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class TableStatisticsClient extends EntityClient<
  Types.TableStatistics,
  null,
  null,
  Types.TableStatisticsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "TableStatistics", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.TableStatistics> = {}) => {
      return this.executeQuery<number>(
        {
          key: "TableStatistics.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.TableStatistics> = {}) => {
      return this.executeQuery<Types.TableStatisticsAggregate>(
        {
          key: "TableStatistics.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.TableStatistics> = {}) {
    return this.executeQuery<Types.TableStatistics[]>(
      {
        key: "TableStatistics.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.TableStatistics>) {
    return this.executeQuery<Types.TableStatistics>(
      {
        key: "TableStatistics.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class TagsClient extends EntityClient<
  Types.Tags,
  null,
  null,
  Types.TagsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Tags", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Tags> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Tags.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Tags> = {}) => {
      return this.executeQuery<Types.TagsAggregate>(
        {
          key: "Tags.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Tags> = {}) {
    return this.executeQuery<Types.Tags[]>(
      {
        key: "Tags.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Tags>) {
    return this.executeQuery<Types.Tags>(
      {
        key: "Tags.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class UserMetricsClient extends EntityClient<
  Types.UserMetrics,
  null,
  null,
  Types.UserMetricsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "UserMetrics", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.UserMetrics> = {}) => {
      return this.executeQuery<number>(
        {
          key: "UserMetrics.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.UserMetrics> = {}) => {
      return this.executeQuery<Types.UserMetricsAggregate>(
        {
          key: "UserMetrics.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.UserMetrics> = {}) {
    return this.executeQuery<Types.UserMetrics[]>(
      {
        key: "UserMetrics.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.UserMetrics>) {
    return this.executeQuery<Types.UserMetrics>(
      {
        key: "UserMetrics.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class UserProfilesClient extends EntityClient<
  Types.UserProfiles,
  null,
  null,
  Types.UserProfilesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "UserProfiles", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.UserProfiles> = {}) => {
      return this.executeQuery<number>(
        {
          key: "UserProfiles.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.UserProfiles> = {}) => {
      return this.executeQuery<Types.UserProfilesAggregate>(
        {
          key: "UserProfiles.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.UserProfiles> = {}) {
    return this.executeQuery<Types.UserProfiles[]>(
      {
        key: "UserProfiles.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.UserProfiles>) {
    return this.executeQuery<Types.UserProfiles>(
      {
        key: "UserProfiles.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class VotesClient extends EntityClient<
  Types.Votes,
  null,
  null,
  Types.VotesBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Votes", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Votes> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Votes.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Votes> = {}) => {
      return this.executeQuery<Types.VotesAggregate>(
        {
          key: "Votes.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Votes> = {}) {
    return this.executeQuery<Types.Votes[]>(
      {
        key: "Votes.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Votes>) {
    return this.executeQuery<Types.Votes>(
      {
        key: "Votes.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}

export class WorkflowsClient extends EntityClient<
  Types.Workflows,
  null,
  null,
  Types.WorkflowsBoolExp
> {
  constructor(config: ClientConfig) {
    super(config, "Workflows", {
      fields: ["id"],
      relations: {},
    } as const);
  }

  // Aggregate Methods
  aggregate = {
    count: async (args: FindManyArgs<Types.Workflows> = {}) => {
      return this.executeQuery<number>(
        {
          key: "Workflows.count",
          document: this.getCountDocument(),
        },
        args,
      );
    },

    group: async (args: FindManyArgs<Types.Workflows> = {}) => {
      return this.executeQuery<Types.WorkflowsAggregate>(
        {
          key: "Workflows.aggregate",
          document: this.getAggregateDocument(
            this.buildFieldSelection(args.select),
          ),
        },
        args,
      );
    },
  };

  async findMany(args: FindManyArgs<Types.Workflows> = {}) {
    return this.executeQuery<Types.Workflows[]>(
      {
        key: "Workflows.findMany",
        document: this.getFindManyDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  async findUnique(args: FindUniqueArgs<Types.Workflows>) {
    return this.executeQuery<Types.Workflows>(
      {
        key: "Workflows.findUnique",
        document: this.getFindUniqueDocument(
          this.buildFieldSelection(args.select),
        ),
      },
      args,
    );
  }

  // Document Methods

  protected getFindManyDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}s($where: Types.${this.entityName}WhereInput, $orderBy: Types.${this.entityName}OrderByInput, $take: Int, $skip: Int) {
        ${this.entityName.toLowerCase()}s(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
          ${selection}
        }
      }
    `);
  }

  protected getFindUniqueDocument(selection: string): DocumentNode {
    return gql(`
      query find${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        ${this.entityName.toLowerCase()}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCreateDocument(selection: string): DocumentNode {
    return gql(`
      mutation create${this.entityName}($data: Types.${this.entityName}InsertInput!) {
        create${this.entityName}(data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getUpdateDocument(selection: string): DocumentNode {
    return gql(`
      mutation update${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!, $data: Types.${this.entityName}SetInput!) {
        update${this.entityName}(where: $where, data: $data) {
          ${selection}
        }
      }
    `);
  }

  protected getDeleteDocument(selection: string): DocumentNode {
    return gql(`
      mutation delete${this.entityName}($where: Types.${this.entityName}WhereUniqueInput!) {
        delete${this.entityName}(where: $where) {
          ${selection}
        }
      }
    `);
  }

  protected getCountDocument(): DocumentNode {
    return gql(`
      query count${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          count
        }
      }
    `);
  }

  protected getAggregateDocument(selection: string): DocumentNode {
    return gql(`
      query aggregate${this.entityName}s($where: Types.${this.entityName}WhereInput) {
        ${this.entityName.toLowerCase()}Aggregate(where: $where) {
          ${selection}
        }
      }
    `);
  }
}