export type Maybe<T> = T | null;
export type InputMaybe<T> = T | null | undefined;
export type Exact<T extends { [key: string]: unknown }> = {
  [K in keyof T]: T[K];
};
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
  [SubKey in K]?: Maybe<T[SubKey]>;
};
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
  [SubKey in K]: Maybe<T[SubKey]>;
};
export type MakeEmpty<
  T extends { [key: string]: unknown },
  K extends keyof T,
> = { [_ in K]?: never };
export type Incremental<T> =
  | T
  | {
      [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never;
    };
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: { input: string; output: string };
  String: { input: string; output: string };
  Boolean: { input: boolean; output: boolean };
  Int: { input: number; output: number };
  Float: { input: number; output: number };
  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: number; output: number };
  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: Record<string, any>; output: Record<string, any> };
  lquery: { input: any; output: any };
  ltree: { input: any; output: any };
  ltxtquery: { input: any; output: any };
  numeric: { input: number; output: number };
  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: string; output: string };
  timestamptz: { input: string; output: string };
  uuid: { input: string; output: string };
  vector: { input: any; output: any };
};

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

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

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

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

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

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

/** aggregated selection of "ad_daily_metrics" */
export interface AdDailyMetricsAggregate {
  readonly aggregate?: Maybe<AdDailyMetricsAggregateFields>;
  readonly nodes: ReadonlyArray<AdDailyMetrics>;
}

export interface AdDailyMetricsAggregateBoolExp {
  readonly count?: InputMaybe<AdDailyMetricsAggregateBoolExpCount>;
}

export interface AdDailyMetricsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<AdDailyMetricsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<AdDailyMetricsBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

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

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

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

/** unique or primary key constraints on table "ad_daily_metrics" */
export type AdDailyMetricsConstraint =
  /** unique or primary key constraint on columns "id" */
  | "ad_daily_metrics_pkey"
  /** unique or primary key constraint on columns "variant_id", "date" */
  | "ad_daily_metrics_variant_id_date_key";

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

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

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

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

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

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

/** response of any mutation on the table "ad_daily_metrics" */
export interface AdDailyMetricsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<AdDailyMetrics>;
}

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

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

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

/** select columns of table "ad_daily_metrics" */
export type AdDailyMetricsSelectColumn =
  /** column name */
  | "clicks"
  /** column name */
  | "created_at"
  /** column name */
  | "date"
  /** column name */
  | "id"
  /** column name */
  | "updated_at"
  /** column name */
  | "variant_id"
  /** column name */
  | "views";

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

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

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

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

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

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

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

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

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

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

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

/** update columns of table "ad_daily_metrics" */
export type AdDailyMetricsUpdateColumn =
  /** column name */
  | "clicks"
  /** column name */
  | "created_at"
  /** column name */
  | "date"
  /** column name */
  | "id"
  /** column name */
  | "updated_at"
  /** column name */
  | "variant_id"
  /** column name */
  | "views";

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

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

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

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

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

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

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

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

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

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

/** aggregated selection of "ad_packages" */
export interface AdPackagesAggregate {
  readonly aggregate?: Maybe<AdPackagesAggregateFields>;
  readonly nodes: ReadonlyArray<AdPackages>;
}

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

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

/** aggregate avg on columns */
export interface AdPackagesAvgFields {
  readonly avg_roi?: Maybe<Scalars["Float"]["output"]>;
  readonly expected_ctr?: Maybe<Scalars["Float"]["output"]>;
  readonly price?: Maybe<Scalars["Float"]["output"]>;
  readonly 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 interface AdPackagesBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<AdPackagesBoolExp>>;
  readonly _not?: InputMaybe<AdPackagesBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<AdPackagesBoolExp>>;
  readonly active?: InputMaybe<BooleanComparisonExp>;
  readonly ads?: InputMaybe<AdsBoolExp>;
  readonly ads_aggregate?: InputMaybe<AdsAggregateBoolExp>;
  readonly avg_roi?: InputMaybe<NumericComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly description?: InputMaybe<StringComparisonExp>;
  readonly expected_ctr?: InputMaybe<NumericComparisonExp>;
  readonly features?: InputMaybe<StringArrayComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly name?: InputMaybe<StringComparisonExp>;
  readonly position?: InputMaybe<StringComparisonExp>;
  readonly price?: InputMaybe<NumericComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly view_frequency?: InputMaybe<NumericComparisonExp>;
}

/** unique or primary key constraints on table "ad_packages" */
export type AdPackagesConstraint =
  /** unique or primary key constraint on columns "id" */
  "ad_packages_pkey";

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

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

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

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

/** response of any mutation on the table "ad_packages" */
export interface AdPackagesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<AdPackages>;
}

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

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

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

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

/** select columns of table "ad_packages" */
export type AdPackagesSelectColumn =
  /** column name */
  | "active"
  /** column name */
  | "avg_roi"
  /** column name */
  | "created_at"
  /** column name */
  | "description"
  /** column name */
  | "expected_ctr"
  /** column name */
  | "features"
  /** column name */
  | "id"
  /** column name */
  | "name"
  /** column name */
  | "position"
  /** column name */
  | "price"
  /** column name */
  | "updated_at"
  /** column name */
  | "view_frequency";

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

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

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

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

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

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

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

/** update columns of table "ad_packages" */
export type AdPackagesUpdateColumn =
  /** column name */
  | "active"
  /** column name */
  | "avg_roi"
  /** column name */
  | "created_at"
  /** column name */
  | "description"
  /** column name */
  | "expected_ctr"
  /** column name */
  | "features"
  /** column name */
  | "id"
  /** column name */
  | "name"
  /** column name */
  | "position"
  /** column name */
  | "price"
  /** column name */
  | "updated_at"
  /** column name */
  | "view_frequency";

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

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

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

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

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

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

/** columns and relationships of "ad_variants" */
export type AdVariantsAdDailyMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdDailyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<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 interface AdVariantsAggregate {
  readonly aggregate?: Maybe<AdVariantsAggregateFields>;
  readonly nodes: ReadonlyArray<AdVariants>;
}

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

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

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

export interface AdVariantsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<AdVariantsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<AdVariantsBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

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

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

/** unique or primary key constraints on table "ad_variants" */
export type AdVariantsConstraint =
  /** unique or primary key constraint on columns "id" */
  "ad_variants_pkey";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface AdVariantsDeleteAtPathInput {
  readonly content?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
  readonly performance_metrics?: InputMaybe<
    ReadonlyArray<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 interface AdVariantsDeleteElemInput {
  readonly content?: InputMaybe<Scalars["Int"]["input"]>;
  readonly performance_metrics?: InputMaybe<Scalars["Int"]["input"]>;
}

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

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

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

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

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

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

/** response of any mutation on the table "ad_variants" */
export interface AdVariantsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<AdVariants>;
}

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

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

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

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

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

/** select columns of table "ad_variants" */
export type AdVariantsSelectColumn =
  /** column name */
  | "active"
  /** column name */
  | "ad_id"
  /** column name */
  | "content"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "is_control"
  /** column name */
  | "performance_metrics"
  /** column name */
  | "updated_at";

/** select "ad_variants_aggregate_bool_exp_bool_and_arguments_columns" columns of table "ad_variants" */
export type AdVariantsSelectColumnAdVariantsAggregateBoolExpBoolAndArgumentsColumns =
  /** column name */
  | "active"
  /** column name */
  | "is_control";

/** select "ad_variants_aggregate_bool_exp_bool_or_arguments_columns" columns of table "ad_variants" */
export type AdVariantsSelectColumnAdVariantsAggregateBoolExpBoolOrArgumentsColumns =
  /** column name */
  | "active"
  /** column name */
  | "is_control";

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

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

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

/** update columns of table "ad_variants" */
export type AdVariantsUpdateColumn =
  /** column name */
  | "active"
  /** column name */
  | "ad_id"
  /** column name */
  | "content"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "is_control"
  /** column name */
  | "performance_metrics"
  /** column name */
  | "updated_at";

export interface AdVariantsUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<AdVariantsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<AdVariantsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<AdVariantsDeleteKeyInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<AdVariantsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<AdVariantsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: AdVariantsBoolExp;
}

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

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

/** aggregated selection of "addresses" */
export interface AddressesAggregate {
  readonly aggregate?: Maybe<AddressesAggregateFields>;
  readonly nodes: ReadonlyArray<Addresses>;
}

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

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

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

export interface AddressesAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<AddressesSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<AddressesBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

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

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

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

/** unique or primary key constraints on table "addresses" */
export type AddressesConstraint =
  /** unique or primary key constraint on columns "id" */
  "addresses_pkey";

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

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

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

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

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

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

/** response of any mutation on the table "addresses" */
export interface AddressesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Addresses>;
}

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

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

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

/** select columns of table "addresses" */
export type AddressesSelectColumn =
  /** column name */
  | "address_type"
  /** column name */
  | "city_id"
  /** column name */
  | "company_id"
  /** column name */
  | "country_id"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "is_primary"
  /** column name */
  | "name"
  /** column name */
  | "street1"
  /** column name */
  | "street2"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

/** select "addresses_aggregate_bool_exp_bool_and_arguments_columns" columns of table "addresses" */
export type AddressesSelectColumnAddressesAggregateBoolExpBoolAndArgumentsColumns =
  /** column name */
  "is_primary";

/** select "addresses_aggregate_bool_exp_bool_or_arguments_columns" columns of table "addresses" */
export type AddressesSelectColumnAddressesAggregateBoolExpBoolOrArgumentsColumns =
  /** column name */
  "is_primary";

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

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

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

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

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

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

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

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

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

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

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

/** update columns of table "addresses" */
export type AddressesUpdateColumn =
  /** column name */
  | "address_type"
  /** column name */
  | "city_id"
  /** column name */
  | "company_id"
  /** column name */
  | "country_id"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "is_primary"
  /** column name */
  | "name"
  /** column name */
  | "street1"
  /** column name */
  | "street2"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

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

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

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

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

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

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

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

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

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

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

/** aggregated selection of "ads" */
export interface AdsAggregate {
  readonly aggregate?: Maybe<AdsAggregateFields>;
  readonly nodes: ReadonlyArray<Ads>;
}

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

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

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

export interface AdsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<AdsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<AdsBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

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

/** unique or primary key constraints on table "ads" */
export type AdsConstraint =
  /** unique or primary key constraint on columns "id" */
  "ads_pkey";

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

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

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

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

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

/** response of any mutation on the table "ads" */
export interface AdsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Ads>;
}

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

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

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

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

/** select columns of table "ads" */
export type AdsSelectColumn =
  /** column name */
  | "active"
  /** column name */
  | "company_id"
  /** column name */
  | "created_at"
  /** column name */
  | "end_date"
  /** column name */
  | "id"
  /** column name */
  | "package_id"
  /** column name */
  | "start_date"
  /** column name */
  | "updated_at";

/** select "ads_aggregate_bool_exp_bool_and_arguments_columns" columns of table "ads" */
export type AdsSelectColumnAdsAggregateBoolExpBoolAndArgumentsColumns =
  /** column name */
  "active";

/** select "ads_aggregate_bool_exp_bool_or_arguments_columns" columns of table "ads" */
export type AdsSelectColumnAdsAggregateBoolExpBoolOrArgumentsColumns =
  /** column name */
  "active";

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

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

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

/** update columns of table "ads" */
export type AdsUpdateColumn =
  /** column name */
  | "active"
  /** column name */
  | "company_id"
  /** column name */
  | "created_at"
  /** column name */
  | "end_date"
  /** column name */
  | "id"
  /** column name */
  | "package_id"
  /** column name */
  | "start_date"
  /** column name */
  | "updated_at";

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

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

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

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

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

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

/** aggregated selection of "blacklisted_domains" */
export interface BlacklistedDomainsAggregate {
  readonly aggregate?: Maybe<BlacklistedDomainsAggregateFields>;
  readonly nodes: ReadonlyArray<BlacklistedDomains>;
}

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

/** aggregate fields of "blacklisted_domains" */
export type BlacklistedDomainsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<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 interface BlacklistedDomainsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<BlacklistedDomainsBoolExp>>;
  readonly _not?: InputMaybe<BlacklistedDomainsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<BlacklistedDomainsBoolExp>>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly reason?: InputMaybe<StringComparisonExp>;
  readonly url?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "blacklisted_domains" */
export type BlacklistedDomainsConstraint =
  /** unique or primary key constraint on columns "id" */
  | "blacklisted_domains_pkey"
  /** unique or primary key constraint on columns "url" */
  | "blacklisted_domains_url_key";

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

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

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

/** response of any mutation on the table "blacklisted_domains" */
export interface BlacklistedDomainsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<BlacklistedDomains>;
}

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

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

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

/** select columns of table "blacklisted_domains" */
export type BlacklistedDomainsSelectColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "reason"
  /** column name */
  | "url";

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

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

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

/** update columns of table "blacklisted_domains" */
export type BlacklistedDomainsUpdateColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "reason"
  /** column name */
  | "url";

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

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

/** aggregated selection of "blacklisted_urls" */
export interface BlacklistedUrlsAggregate {
  readonly aggregate?: Maybe<BlacklistedUrlsAggregateFields>;
  readonly nodes: ReadonlyArray<BlacklistedUrls>;
}

export interface BlacklistedUrlsAggregateBoolExp {
  readonly count?: InputMaybe<BlacklistedUrlsAggregateBoolExpCount>;
}

export interface BlacklistedUrlsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<BlacklistedUrlsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<BlacklistedUrlsBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

/** aggregate avg on columns */
export interface BlacklistedUrlsAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

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

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

/** unique or primary key constraints on table "blacklisted_urls" */
export type BlacklistedUrlsConstraint =
  /** unique or primary key constraint on columns "id" */
  | "blacklisted_urls_pkey"
  /** unique or primary key constraint on columns "url" */
  | "blacklisted_urls_url_key";

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

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

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

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

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

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

/** response of any mutation on the table "blacklisted_urls" */
export interface BlacklistedUrlsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<BlacklistedUrls>;
}

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

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

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

/** select columns of table "blacklisted_urls" */
export type BlacklistedUrlsSelectColumn =
  /** column name */
  | "company_id"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "reason"
  /** column name */
  | "url";

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

/** aggregate stddev on columns */
export interface BlacklistedUrlsStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

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

/** aggregate stddev_pop on columns */
export interface BlacklistedUrlsStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

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

/** aggregate stddev_samp on columns */
export interface BlacklistedUrlsStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

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

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

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

/** aggregate sum on columns */
export interface BlacklistedUrlsSumFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
}

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

/** update columns of table "blacklisted_urls" */
export type BlacklistedUrlsUpdateColumn =
  /** column name */
  | "company_id"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "reason"
  /** column name */
  | "url";

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

/** aggregate var_pop on columns */
export interface BlacklistedUrlsVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

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

/** aggregate var_samp on columns */
export interface BlacklistedUrlsVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

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

/** aggregate variance on columns */
export interface BlacklistedUrlsVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

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

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

/** aggregated selection of "blocked_ips" */
export interface BlockedIpsAggregate {
  readonly aggregate?: Maybe<BlockedIpsAggregateFields>;
  readonly nodes: ReadonlyArray<BlockedIps>;
}

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

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

/** aggregate avg on columns */
export interface BlockedIpsAvgFields {
  readonly 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 interface BlockedIpsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<BlockedIpsBoolExp>>;
  readonly _not?: InputMaybe<BlockedIpsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<BlockedIpsBoolExp>>;
  readonly blocked_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly blocked_until?: InputMaybe<TimestamptzComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly failed_attempts?: InputMaybe<IntComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly ip_address?: InputMaybe<InetComparisonExp>;
  readonly reason?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
}

/** unique or primary key constraints on table "blocked_ips" */
export type BlockedIpsConstraint =
  /** unique or primary key constraint on columns "id" */
  "blocked_ips_pkey";

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

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

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

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

/** response of any mutation on the table "blocked_ips" */
export interface BlockedIpsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<BlockedIps>;
}

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

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

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

/** select columns of table "blocked_ips" */
export type BlockedIpsSelectColumn =
  /** column name */
  | "blocked_at"
  /** column name */
  | "blocked_until"
  /** column name */
  | "created_at"
  /** column name */
  | "failed_attempts"
  /** column name */
  | "id"
  /** column name */
  | "ip_address"
  /** column name */
  | "reason"
  /** column name */
  | "updated_at";

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

/** aggregate stddev on columns */
export interface BlockedIpsStddevFields {
  readonly failed_attempts?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface BlockedIpsStddevPopFields {
  readonly failed_attempts?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface BlockedIpsStddevSampFields {
  readonly failed_attempts?: Maybe<Scalars["Float"]["output"]>;
}

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

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

/** aggregate sum on columns */
export interface BlockedIpsSumFields {
  readonly failed_attempts?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "blocked_ips" */
export type BlockedIpsUpdateColumn =
  /** column name */
  | "blocked_at"
  /** column name */
  | "blocked_until"
  /** column name */
  | "created_at"
  /** column name */
  | "failed_attempts"
  /** column name */
  | "id"
  /** column name */
  | "ip_address"
  /** column name */
  | "reason"
  /** column name */
  | "updated_at";

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

/** aggregate var_pop on columns */
export interface BlockedIpsVarPopFields {
  readonly failed_attempts?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface BlockedIpsVarSampFields {
  readonly failed_attempts?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface BlockedIpsVarianceFields {
  readonly failed_attempts?: Maybe<Scalars["Float"]["output"]>;
}

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

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

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

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

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

/** aggregated selection of "bookmark_folders" */
export interface BookmarkFoldersAggregate {
  readonly aggregate?: Maybe<BookmarkFoldersAggregateFields>;
  readonly nodes: ReadonlyArray<BookmarkFolders>;
}

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

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

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

export interface BookmarkFoldersAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<BookmarkFoldersSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<BookmarkFoldersBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

/** aggregate avg on columns */
export interface BookmarkFoldersAvgFields {
  readonly position?: Maybe<Scalars["Float"]["output"]>;
}

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

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

/** unique or primary key constraints on table "bookmark_folders" */
export type BookmarkFoldersConstraint =
  /** unique or primary key constraint on columns "id" */
  | "bookmark_folders_pkey"
  /** unique or primary key constraint on columns "user_id" */
  | "one_default_per_user";

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

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

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

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

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

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

/** response of any mutation on the table "bookmark_folders" */
export interface BookmarkFoldersMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<BookmarkFolders>;
}

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

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

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

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

/** select columns of table "bookmark_folders" */
export type BookmarkFoldersSelectColumn =
  /** column name */
  | "color"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "is_default"
  /** column name */
  | "is_favorite"
  /** column name */
  | "name"
  /** column name */
  | "parent_id"
  /** column name */
  | "path"
  /** column name */
  | "position"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

/** select "bookmark_folders_aggregate_bool_exp_bool_and_arguments_columns" columns of table "bookmark_folders" */
export type BookmarkFoldersSelectColumnBookmarkFoldersAggregateBoolExpBoolAndArgumentsColumns =
  /** column name */
  | "is_default"
  /** column name */
  | "is_favorite";

/** select "bookmark_folders_aggregate_bool_exp_bool_or_arguments_columns" columns of table "bookmark_folders" */
export type BookmarkFoldersSelectColumnBookmarkFoldersAggregateBoolExpBoolOrArgumentsColumns =
  /** column name */
  | "is_default"
  /** column name */
  | "is_favorite";

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

/** aggregate stddev on columns */
export interface BookmarkFoldersStddevFields {
  readonly position?: Maybe<Scalars["Float"]["output"]>;
}

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

/** aggregate stddev_pop on columns */
export interface BookmarkFoldersStddevPopFields {
  readonly position?: Maybe<Scalars["Float"]["output"]>;
}

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

/** aggregate stddev_samp on columns */
export interface BookmarkFoldersStddevSampFields {
  readonly position?: Maybe<Scalars["Float"]["output"]>;
}

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

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

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

/** aggregate sum on columns */
export interface BookmarkFoldersSumFields {
  readonly position?: Maybe<Scalars["Int"]["output"]>;
}

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

/** update columns of table "bookmark_folders" */
export type BookmarkFoldersUpdateColumn =
  /** column name */
  | "color"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "is_default"
  /** column name */
  | "is_favorite"
  /** column name */
  | "name"
  /** column name */
  | "parent_id"
  /** column name */
  | "path"
  /** column name */
  | "position"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

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

/** aggregate var_pop on columns */
export interface BookmarkFoldersVarPopFields {
  readonly position?: Maybe<Scalars["Float"]["output"]>;
}

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

/** aggregate var_samp on columns */
export interface BookmarkFoldersVarSampFields {
  readonly position?: Maybe<Scalars["Float"]["output"]>;
}

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

/** aggregate variance on columns */
export interface BookmarkFoldersVarianceFields {
  readonly position?: Maybe<Scalars["Float"]["output"]>;
}

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

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

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

/** aggregated selection of "bookmarks" */
export interface BookmarksAggregate {
  readonly aggregate?: Maybe<BookmarksAggregateFields>;
  readonly nodes: ReadonlyArray<Bookmarks>;
}

export interface BookmarksAggregateBoolExp {
  readonly count?: InputMaybe<BookmarksAggregateBoolExpCount>;
}

export interface BookmarksAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<BookmarksSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<BookmarksBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

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

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

/** unique or primary key constraints on table "bookmarks" */
export type BookmarksConstraint =
  /** unique or primary key constraint on columns "id" */
  | "bookmarks_pkey"
  /** unique or primary key constraint on columns "content_id", "user_id", "content_type" */
  | "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 interface BookmarksDeleteAtPathInput {
  readonly metadata?: InputMaybe<ReadonlyArray<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 interface BookmarksDeleteElemInput {
  readonly metadata?: InputMaybe<Scalars["Int"]["input"]>;
}

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

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

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

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

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

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

/** response of any mutation on the table "bookmarks" */
export interface BookmarksMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Bookmarks>;
}

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

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

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

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

/** select columns of table "bookmarks" */
export type BookmarksSelectColumn =
  /** column name */
  | "content_id"
  /** column name */
  | "content_type"
  /** column name */
  | "created_at"
  /** column name */
  | "folder_id"
  /** column name */
  | "id"
  /** column name */
  | "metadata"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

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

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

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

/** update columns of table "bookmarks" */
export type BookmarksUpdateColumn =
  /** column name */
  | "content_id"
  /** column name */
  | "content_type"
  /** column name */
  | "created_at"
  /** column name */
  | "folder_id"
  /** column name */
  | "id"
  /** column name */
  | "metadata"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

export interface BookmarksUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<BookmarksAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<BookmarksDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<BookmarksDeleteKeyInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<BookmarksPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<BookmarksSetInput>;
  /** filter the rows which have to be updated */
  readonly where: BookmarksBoolExp;
}

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

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

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

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

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

/** aggregated selection of "business_domains" */
export interface BusinessDomainsAggregate {
  readonly aggregate?: Maybe<BusinessDomainsAggregateFields>;
  readonly nodes: ReadonlyArray<BusinessDomains>;
}

export interface BusinessDomainsAggregateBoolExp {
  readonly count?: InputMaybe<BusinessDomainsAggregateBoolExpCount>;
}

export interface BusinessDomainsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<BusinessDomainsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<BusinessDomainsBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

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

/** unique or primary key constraints on table "business_domains" */
export type BusinessDomainsConstraint =
  /** unique or primary key constraint on columns "id" */
  | "business_domains_pkey"
  /** unique or primary key constraint on columns "name" */
  | "unique_domain_name"
  /** unique or primary key constraint on columns "slug" */
  | "unique_domain_slug";

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

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

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

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

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

/** response of any mutation on the table "business_domains" */
export interface BusinessDomainsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<BusinessDomains>;
}

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

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

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

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

/** select columns of table "business_domains" */
export type BusinessDomainsSelectColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "description"
  /** column name */
  | "id"
  /** column name */
  | "name"
  /** column name */
  | "parent_id"
  /** column name */
  | "slug"
  /** column name */
  | "updated_at";

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

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

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

/** update columns of table "business_domains" */
export type BusinessDomainsUpdateColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "description"
  /** column name */
  | "id"
  /** column name */
  | "name"
  /** column name */
  | "parent_id"
  /** column name */
  | "slug"
  /** column name */
  | "updated_at";

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

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

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

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

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

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

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

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

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

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

/** aggregated selection of "categories" */
export interface CategoriesAggregate {
  readonly aggregate?: Maybe<CategoriesAggregateFields>;
  readonly nodes: ReadonlyArray<Categories>;
}

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

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

/** aggregate avg on columns */
export interface CategoriesAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

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

/** unique or primary key constraints on table "categories" */
export type CategoriesConstraint =
  /** unique or primary key constraint on columns "id" */
  | "categories_pkey"
  /** unique or primary key constraint on columns "name" */
  | "categories_title_key";

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

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

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

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

/** response of any mutation on the table "categories" */
export interface CategoriesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Categories>;
}

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

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

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

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

/** select columns of table "categories" */
export type CategoriesSelectColumn =
  /** column name */
  | "body"
  /** column name */
  | "created_at"
  /** column name */
  | "document_id"
  /** column name */
  | "id"
  /** column name */
  | "locale"
  /** column name */
  | "name"
  /** column name */
  | "published_at"
  /** column name */
  | "updated_at";

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

/** aggregate stddev on columns */
export interface CategoriesStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface CategoriesStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface CategoriesStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

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

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

/** aggregate sum on columns */
export interface CategoriesSumFields {
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
}

/** update columns of table "categories" */
export type CategoriesUpdateColumn =
  /** column name */
  | "body"
  /** column name */
  | "created_at"
  /** column name */
  | "document_id"
  /** column name */
  | "id"
  /** column name */
  | "locale"
  /** column name */
  | "name"
  /** column name */
  | "published_at"
  /** column name */
  | "updated_at";

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

/** aggregate var_pop on columns */
export interface CategoriesVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface CategoriesVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface CategoriesVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

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

/** aggregated selection of "categorized_urls" */
export interface CategorizedUrlsAggregate {
  readonly aggregate?: Maybe<CategorizedUrlsAggregateFields>;
  readonly nodes: ReadonlyArray<CategorizedUrls>;
}

export interface CategorizedUrlsAggregateBoolExp {
  readonly count?: InputMaybe<CategorizedUrlsAggregateBoolExpCount>;
}

export interface CategorizedUrlsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<CategorizedUrlsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<CategorizedUrlsBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

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

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

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

/** unique or primary key constraints on table "categorized_urls" */
export type CategorizedUrlsConstraint =
  /** unique or primary key constraint on columns "id" */
  | "categorized_urls_pkey"
  /** unique or primary key constraint on columns "found_on", "url" */
  | "unique_url_found_on";

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

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

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

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

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

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

/** response of any mutation on the table "categorized_urls" */
export interface CategorizedUrlsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<CategorizedUrls>;
}

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

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

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

/** select columns of table "categorized_urls" */
export type CategorizedUrlsSelectColumn =
  /** column name */
  | "categorizer_version"
  /** column name */
  | "company_id"
  /** column name */
  | "confidence"
  /** column name */
  | "content_hash"
  /** column name */
  | "created_at"
  /** column name */
  | "domain_id"
  /** column name */
  | "found_on"
  /** column name */
  | "id"
  /** column name */
  | "priority"
  /** column name */
  | "updated_at"
  /** column name */
  | "url";

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

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

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

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

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

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

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

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

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

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

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

/** update columns of table "categorized_urls" */
export type CategorizedUrlsUpdateColumn =
  /** column name */
  | "categorizer_version"
  /** column name */
  | "company_id"
  /** column name */
  | "confidence"
  /** column name */
  | "content_hash"
  /** column name */
  | "created_at"
  /** column name */
  | "domain_id"
  /** column name */
  | "found_on"
  /** column name */
  | "id"
  /** column name */
  | "priority"
  /** column name */
  | "updated_at"
  /** column name */
  | "url";

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

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

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

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

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

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

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

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

/** aggregated selection of "circuit_breaker_states" */
export interface CircuitBreakerStatesAggregate {
  readonly aggregate?: Maybe<CircuitBreakerStatesAggregateFields>;
  readonly nodes: ReadonlyArray<CircuitBreakerStates>;
}

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

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

/** aggregate avg on columns */
export interface CircuitBreakerStatesAvgFields {
  readonly 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 interface CircuitBreakerStatesBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<CircuitBreakerStatesBoolExp>>;
  readonly _not?: InputMaybe<CircuitBreakerStatesBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<CircuitBreakerStatesBoolExp>>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly failure_count?: InputMaybe<IntComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly job_name?: InputMaybe<StringComparisonExp>;
  readonly last_failure?: InputMaybe<TimestamptzComparisonExp>;
  readonly last_success?: InputMaybe<TimestamptzComparisonExp>;
  readonly state?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
}

/** unique or primary key constraints on table "circuit_breaker_states" */
export type CircuitBreakerStatesConstraint =
  /** unique or primary key constraint on columns "job_name" */
  | "circuit_breaker_states_job_name_key"
  /** unique or primary key constraint on columns "id" */
  | "circuit_breaker_states_pkey";

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

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

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

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

/** response of any mutation on the table "circuit_breaker_states" */
export interface CircuitBreakerStatesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<CircuitBreakerStates>;
}

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

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

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

/** select columns of table "circuit_breaker_states" */
export type CircuitBreakerStatesSelectColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "failure_count"
  /** column name */
  | "id"
  /** column name */
  | "job_name"
  /** column name */
  | "last_failure"
  /** column name */
  | "last_success"
  /** column name */
  | "state"
  /** column name */
  | "updated_at";

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

/** aggregate stddev on columns */
export interface CircuitBreakerStatesStddevFields {
  readonly failure_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface CircuitBreakerStatesStddevPopFields {
  readonly failure_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface CircuitBreakerStatesStddevSampFields {
  readonly failure_count?: Maybe<Scalars["Float"]["output"]>;
}

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

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

/** aggregate sum on columns */
export interface CircuitBreakerStatesSumFields {
  readonly failure_count?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "circuit_breaker_states" */
export type CircuitBreakerStatesUpdateColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "failure_count"
  /** column name */
  | "id"
  /** column name */
  | "job_name"
  /** column name */
  | "last_failure"
  /** column name */
  | "last_success"
  /** column name */
  | "state"
  /** column name */
  | "updated_at";

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

/** aggregate var_pop on columns */
export interface CircuitBreakerStatesVarPopFields {
  readonly failure_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface CircuitBreakerStatesVarSampFields {
  readonly failure_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface CircuitBreakerStatesVarianceFields {
  readonly failure_count?: Maybe<Scalars["Float"]["output"]>;
}

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

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

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

/** aggregated selection of "cities" */
export interface CitiesAggregate {
  readonly aggregate?: Maybe<CitiesAggregateFields>;
  readonly nodes: ReadonlyArray<Cities>;
}

export interface CitiesAggregateBoolExp {
  readonly count?: InputMaybe<CitiesAggregateBoolExpCount>;
}

export interface CitiesAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<CitiesSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<CitiesBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

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

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

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

/** unique or primary key constraints on table "cities" */
export type CitiesConstraint =
  /** unique or primary key constraint on columns "name" */
  | "cities_name_key"
  /** unique or primary key constraint on columns "id" */
  | "cities_pkey";

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

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

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

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

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

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

/** response of any mutation on the table "cities" */
export interface CitiesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Cities>;
}

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

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

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

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

/** select columns of table "cities" */
export type CitiesSelectColumn =
  /** column name */
  | "country_id"
  /** column name */
  | "id"
  /** column name */
  | "name"
  /** column name */
  | "state";

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

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

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

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

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

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

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

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

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

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

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

/** update columns of table "cities" */
export type CitiesUpdateColumn =
  /** column name */
  | "country_id"
  /** column name */
  | "id"
  /** column name */
  | "name"
  /** column name */
  | "state";

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

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

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

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

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

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

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

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

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

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

/** aggregated selection of "comments" */
export interface CommentsAggregate {
  readonly aggregate?: Maybe<CommentsAggregateFields>;
  readonly nodes: ReadonlyArray<Comments>;
}

export interface CommentsAggregateBoolExp {
  readonly count?: InputMaybe<CommentsAggregateBoolExpCount>;
}

export interface CommentsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<CommentsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<CommentsBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

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

/** unique or primary key constraints on table "comments" */
export type CommentsConstraint =
  /** unique or primary key constraint on columns "id" */
  "comments_pkey";

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

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

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

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

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

/** response of any mutation on the table "comments" */
export interface CommentsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Comments>;
}

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

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

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

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

/** select columns of table "comments" */
export type CommentsSelectColumn =
  /** column name */
  | "content"
  /** column name */
  | "content_id"
  /** column name */
  | "content_type"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "parent_comment_id"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

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

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

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

/** update columns of table "comments" */
export type CommentsUpdateColumn =
  /** column name */
  | "content"
  /** column name */
  | "content_id"
  /** column name */
  | "content_type"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "parent_comment_id"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** columns and relationships of "companies" */
export type CompaniesContentSourcesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<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<ReadonlyArray<NewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsOrderBy>>;
  where?: InputMaybe<NewsBoolExp>;
};

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

/** aggregated selection of "companies" */
export interface CompaniesAggregate {
  readonly aggregate?: Maybe<CompaniesAggregateFields>;
  readonly nodes: ReadonlyArray<Companies>;
}

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

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

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

export interface CompaniesAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<CompaniesSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<CompaniesBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

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

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

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

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

/** unique or primary key constraints on table "companies" */
export type CompaniesConstraint =
  /** unique or primary key constraint on columns "id" */
  | "companies_id_key1"
  /** unique or primary key constraint on columns "id" */
  | "companies_pkey"
  /** unique or primary key constraint on columns "url" */
  | "companies_website_url_key";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface CompaniesDeleteAtPathInput {
  readonly keywords?: InputMaybe<ReadonlyArray<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 interface CompaniesDeleteElemInput {
  readonly keywords?: InputMaybe<Scalars["Int"]["input"]>;
}

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

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

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

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

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

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

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

/** response of any mutation on the table "companies" */
export interface CompaniesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Companies>;
}

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

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

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

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

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

/** select columns of table "companies" */
export type CompaniesSelectColumn =
  /** column name */
  | "category"
  /** column name */
  | "category_id"
  /** column name */
  | "content_status"
  /** column name */
  | "created_at"
  /** column name */
  | "description"
  /** column name */
  | "failed_count"
  /** column name */
  | "founding_year"
  /** column name */
  | "id"
  /** column name */
  | "is_english"
  /** column name */
  | "is_government"
  /** column name */
  | "keywords"
  /** column name */
  | "logo_url"
  /** column name */
  | "name"
  /** column name */
  | "scrape_frequency"
  /** column name */
  | "scrape_rating"
  /** column name */
  | "scraped_at"
  /** column name */
  | "social_media_id"
  /** column name */
  | "updated_at"
  /** column name */
  | "url";

/** select "companies_aggregate_bool_exp_bool_and_arguments_columns" columns of table "companies" */
export type CompaniesSelectColumnCompaniesAggregateBoolExpBoolAndArgumentsColumns =
  /** column name */
  | "is_english"
  /** column name */
  | "is_government";

/** select "companies_aggregate_bool_exp_bool_or_arguments_columns" columns of table "companies" */
export type CompaniesSelectColumnCompaniesAggregateBoolExpBoolOrArgumentsColumns =
  /** column name */
  | "is_english"
  /** column name */
  | "is_government";

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

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

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

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

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

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

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

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

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

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

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

/** update columns of table "companies" */
export type CompaniesUpdateColumn =
  /** column name */
  | "category"
  /** column name */
  | "category_id"
  /** column name */
  | "content_status"
  /** column name */
  | "created_at"
  /** column name */
  | "description"
  /** column name */
  | "failed_count"
  /** column name */
  | "founding_year"
  /** column name */
  | "id"
  /** column name */
  | "is_english"
  /** column name */
  | "is_government"
  /** column name */
  | "keywords"
  /** column name */
  | "logo_url"
  /** column name */
  | "name"
  /** column name */
  | "scrape_frequency"
  /** column name */
  | "scrape_rating"
  /** column name */
  | "scraped_at"
  /** column name */
  | "social_media_id"
  /** column name */
  | "updated_at"
  /** column name */
  | "url";

export interface CompaniesUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<CompaniesAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<CompaniesDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<CompaniesDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<CompaniesIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<CompaniesPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<CompaniesSetInput>;
  /** filter the rows which have to be updated */
  readonly where: CompaniesBoolExp;
}

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

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

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

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

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

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

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

/** aggregated selection of "company_contacts" */
export interface CompanyContactsAggregate {
  readonly aggregate?: Maybe<CompanyContactsAggregateFields>;
  readonly nodes: ReadonlyArray<CompanyContacts>;
}

export interface CompanyContactsAggregateBoolExp {
  readonly count?: InputMaybe<CompanyContactsAggregateBoolExpCount>;
}

export interface CompanyContactsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<CompanyContactsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<CompanyContactsBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

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

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

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

/** unique or primary key constraints on table "company_contacts" */
export type CompanyContactsConstraint =
  /** unique or primary key constraint on columns "id" */
  "company_contacts_pkey";

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

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

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

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

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

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

/** response of any mutation on the table "company_contacts" */
export interface CompanyContactsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<CompanyContacts>;
}

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

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

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

/** select columns of table "company_contacts" */
export type CompanyContactsSelectColumn =
  /** column name */
  | "company_id"
  /** column name */
  | "contact_id"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "updated_at";

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

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

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

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

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

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

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

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

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

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

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

/** update columns of table "company_contacts" */
export type CompanyContactsUpdateColumn =
  /** column name */
  | "company_id"
  /** column name */
  | "contact_id"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "updated_at";

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

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

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

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

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

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

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

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

/** aggregated selection of "company_employees" */
export interface CompanyEmployeesAggregate {
  readonly aggregate?: Maybe<CompanyEmployeesAggregateFields>;
  readonly nodes: ReadonlyArray<CompanyEmployees>;
}

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

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

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

export interface CompanyEmployeesAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<CompanyEmployeesSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<CompanyEmployeesBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

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

/** unique or primary key constraints on table "company_employees" */
export type CompanyEmployeesConstraint =
  /** unique or primary key constraint on columns "id" */
  "company_employees_pkey";

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

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

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

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

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

/** response of any mutation on the table "company_employees" */
export interface CompanyEmployeesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<CompanyEmployees>;
}

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

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

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

/** select columns of table "company_employees" */
export type CompanyEmployeesSelectColumn =
  /** column name */
  | "access_level"
  /** column name */
  | "company_id"
  /** column name */
  | "created_at"
  /** column name */
  | "end_date"
  /** column name */
  | "id"
  /** column name */
  | "job_description"
  /** column name */
  | "role"
  /** column name */
  | "start_date"
  /** column name */
  | "status"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

/** select "company_employees_aggregate_bool_exp_bool_and_arguments_columns" columns of table "company_employees" */
export type CompanyEmployeesSelectColumnCompanyEmployeesAggregateBoolExpBoolAndArgumentsColumns =
  /** column name */
  "status";

/** select "company_employees_aggregate_bool_exp_bool_or_arguments_columns" columns of table "company_employees" */
export type CompanyEmployeesSelectColumnCompanyEmployeesAggregateBoolExpBoolOrArgumentsColumns =
  /** column name */
  "status";

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

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

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

/** update columns of table "company_employees" */
export type CompanyEmployeesUpdateColumn =
  /** column name */
  | "access_level"
  /** column name */
  | "company_id"
  /** column name */
  | "created_at"
  /** column name */
  | "end_date"
  /** column name */
  | "id"
  /** column name */
  | "job_description"
  /** column name */
  | "role"
  /** column name */
  | "start_date"
  /** column name */
  | "status"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

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

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

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

/** aggregated selection of "company_extras" */
export interface CompanyExtrasAggregate {
  readonly aggregate?: Maybe<CompanyExtrasAggregateFields>;
  readonly nodes: ReadonlyArray<CompanyExtras>;
}

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

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

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

export interface CompanyExtrasAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<CompanyExtrasSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<CompanyExtrasBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

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

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

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

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

/** unique or primary key constraints on table "company_extras" */
export type CompanyExtrasConstraint =
  /** unique or primary key constraint on columns "id" */
  | "company_extras_pkey"
  /** unique or primary key constraint on columns "url" */
  | "idx_ce_unique_url";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface CompanyExtrasDeleteAtPathInput {
  readonly review?: InputMaybe<ReadonlyArray<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 interface CompanyExtrasDeleteElemInput {
  readonly review?: InputMaybe<Scalars["Int"]["input"]>;
}

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

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

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

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

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

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

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

/** response of any mutation on the table "company_extras" */
export interface CompanyExtrasMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<CompanyExtras>;
}

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

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

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

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

/** select columns of table "company_extras" */
export type CompanyExtrasSelectColumn =
  /** column name */
  | "body"
  /** column name */
  | "category"
  /** column name */
  | "company_id"
  /** column name */
  | "created_at"
  /** column name */
  | "found_count"
  /** column name */
  | "id"
  /** column name */
  | "level"
  /** column name */
  | "review"
  /** column name */
  | "success"
  /** column name */
  | "updated_at"
  /** column name */
  | "url";

/** select "company_extras_aggregate_bool_exp_bool_and_arguments_columns" columns of table "company_extras" */
export type CompanyExtrasSelectColumnCompanyExtrasAggregateBoolExpBoolAndArgumentsColumns =
  /** column name */
  "success";

/** select "company_extras_aggregate_bool_exp_bool_or_arguments_columns" columns of table "company_extras" */
export type CompanyExtrasSelectColumnCompanyExtrasAggregateBoolExpBoolOrArgumentsColumns =
  /** column name */
  "success";

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

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

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

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

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

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

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

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

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

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

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

/** update columns of table "company_extras" */
export type CompanyExtrasUpdateColumn =
  /** column name */
  | "body"
  /** column name */
  | "category"
  /** column name */
  | "company_id"
  /** column name */
  | "created_at"
  /** column name */
  | "found_count"
  /** column name */
  | "id"
  /** column name */
  | "level"
  /** column name */
  | "review"
  /** column name */
  | "success"
  /** column name */
  | "updated_at"
  /** column name */
  | "url";

export interface CompanyExtrasUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<CompanyExtrasAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<CompanyExtrasDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<CompanyExtrasDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<CompanyExtrasIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<CompanyExtrasPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<CompanyExtrasSetInput>;
  /** filter the rows which have to be updated */
  readonly where: CompanyExtrasBoolExp;
}

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

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

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

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

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

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

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

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

/** aggregated selection of "company_metrics" */
export interface CompanyMetricsAggregate {
  readonly aggregate?: Maybe<CompanyMetricsAggregateFields>;
  readonly nodes: ReadonlyArray<CompanyMetrics>;
}

export interface CompanyMetricsAggregateBoolExp {
  readonly count?: InputMaybe<CompanyMetricsAggregateBoolExpCount>;
}

export interface CompanyMetricsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<CompanyMetricsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<CompanyMetricsBoolExp>;
  readonly predicate: IntComparisonExp;
}

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

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

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

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

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

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

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

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

/** unique or primary key constraints on table "company_metrics" */
export type CompanyMetricsConstraint =
  /** unique or primary key constraint on columns "id" */
  "company_metrics_pkey";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface CompanyMetricsDeleteAtPathInput {
  readonly value?: InputMaybe<ReadonlyArray<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 interface CompanyMetricsDeleteElemInput {
  readonly value?: InputMaybe<Scalars["Int"]["input"]>;
}

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

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

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

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

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

/** aggregate min on columns */
export interface CompanyMetricsMinFields {
  readonly company_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly crawl_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Int"]["output"]>;
  readonly timestamp?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** order by min() on columns of table "company_metrics" */
export interface CompanyMetricsMinOrderBy {
  readonly company_id?: InputMaybe<OrderBy>;
  readonly crawl_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
  readonly timestamp?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "company_metrics" */
export interface CompanyMetricsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<CompanyMetrics>;
}

/** on_conflict condition type for table "company_metrics" */
export interface CompanyMetricsOnConflict {
  readonly constraint: CompanyMetricsConstraint;
  readonly update_columns: ReadonlyArray<CompanyMetricsUpdateColumn>;
  readonly where?: InputMaybe<CompanyMetricsBoolExp>;
}

/** Ordering options when selecting data from "company_metrics". */
export interface CompanyMetricsOrderBy {
  readonly company_id?: InputMaybe<OrderBy>;
  readonly crawl_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_definition?: InputMaybe<MetricDefinitionsOrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
  readonly timestamp?: InputMaybe<OrderBy>;
  readonly value?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: company_metrics */
export interface CompanyMetricsPkColumnsInput {
  readonly id: Scalars["bigint"]["input"];
}

/** prepend existing jsonb value of filtered columns with new jsonb value */
export interface CompanyMetricsPrependInput {
  readonly value?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** select columns of table "company_metrics" */
export type CompanyMetricsSelectColumn =
  /** column name */
  | "company_id"
  /** column name */
  | "crawl_id"
  /** column name */
  | "id"
  /** column name */
  | "metric_id"
  /** column name */
  | "timestamp"
  /** column name */
  | "value";

/** input type for updating data in table "company_metrics" */
export interface CompanyMetricsSetInput {
  readonly company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly crawl_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly metric_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly timestamp?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly value?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** aggregate stddev on columns */
export interface CompanyMetricsStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "company_metrics" */
export interface CompanyMetricsStddevOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface CompanyMetricsStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "company_metrics" */
export interface CompanyMetricsStddevPopOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface CompanyMetricsStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "company_metrics" */
export interface CompanyMetricsStddevSampOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "company_metrics" */
export interface CompanyMetricsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: CompanyMetricsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface CompanyMetricsStreamCursorValueInput {
  readonly company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly crawl_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly metric_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly timestamp?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly value?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** aggregate sum on columns */
export interface CompanyMetricsSumFields {
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Int"]["output"]>;
}

/** order by sum() on columns of table "company_metrics" */
export interface CompanyMetricsSumOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
}

/** update columns of table "company_metrics" */
export type CompanyMetricsUpdateColumn =
  /** column name */
  | "company_id"
  /** column name */
  | "crawl_id"
  /** column name */
  | "id"
  /** column name */
  | "metric_id"
  /** column name */
  | "timestamp"
  /** column name */
  | "value";

export interface CompanyMetricsUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<CompanyMetricsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<CompanyMetricsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<CompanyMetricsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<CompanyMetricsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<CompanyMetricsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<CompanyMetricsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: CompanyMetricsBoolExp;
}

/** aggregate var_pop on columns */
export interface CompanyMetricsVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "company_metrics" */
export interface CompanyMetricsVarPopOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface CompanyMetricsVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "company_metrics" */
export interface CompanyMetricsVarSampOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface CompanyMetricsVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "company_metrics" */
export interface CompanyMetricsVarianceOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
}

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

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

/** columns and relationships of "contacts" */
export interface Contacts {
  /** An object relationship */
  readonly company?: Maybe<Companies>;
  /** An array relationship */
  readonly company_contacts: ReadonlyArray<CompanyContacts>;
  /** An aggregate relationship */
  readonly company_contacts_aggregate: CompanyContactsAggregate;
  readonly company_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly contact_type?: Maybe<Scalars["contact_type"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamp"]["output"]>;
  readonly email?: Maybe<Scalars["String"]["output"]>;
  readonly id: Scalars["Int"]["output"];
  readonly is_primary?: Maybe<Scalars["Boolean"]["output"]>;
  readonly phone?: Maybe<Scalars["String"]["output"]>;
  readonly privacy_level?: Maybe<Scalars["privacy_level"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamp"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
  /** An object relationship */
  readonly user_profile?: Maybe<UserProfiles>;
}

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

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

/** aggregated selection of "contacts" */
export interface ContactsAggregate {
  readonly aggregate?: Maybe<ContactsAggregateFields>;
  readonly nodes: ReadonlyArray<Contacts>;
}

export interface ContactsAggregateBoolExp {
  readonly bool_and?: InputMaybe<ContactsAggregateBoolExpBoolAnd>;
  readonly bool_or?: InputMaybe<ContactsAggregateBoolExpBoolOr>;
  readonly count?: InputMaybe<ContactsAggregateBoolExpCount>;
}

export interface ContactsAggregateBoolExpBoolAnd {
  readonly arguments: ContactsSelectColumnContactsAggregateBoolExpBoolAndArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ContactsBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface ContactsAggregateBoolExpBoolOr {
  readonly arguments: ContactsSelectColumnContactsAggregateBoolExpBoolOrArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ContactsBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface ContactsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<ContactsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ContactsBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "contacts" */
export interface ContactsAggregateFields {
  readonly avg?: Maybe<ContactsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ContactsMaxFields>;
  readonly min?: Maybe<ContactsMinFields>;
  readonly stddev?: Maybe<ContactsStddevFields>;
  readonly stddev_pop?: Maybe<ContactsStddevPopFields>;
  readonly stddev_samp?: Maybe<ContactsStddevSampFields>;
  readonly sum?: Maybe<ContactsSumFields>;
  readonly var_pop?: Maybe<ContactsVarPopFields>;
  readonly var_samp?: Maybe<ContactsVarSampFields>;
  readonly variance?: Maybe<ContactsVarianceFields>;
}

/** aggregate fields of "contacts" */
export type ContactsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ContactsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "contacts" */
export interface ContactsAggregateOrderBy {
  readonly avg?: InputMaybe<ContactsAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<ContactsMaxOrderBy>;
  readonly min?: InputMaybe<ContactsMinOrderBy>;
  readonly stddev?: InputMaybe<ContactsStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<ContactsStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<ContactsStddevSampOrderBy>;
  readonly sum?: InputMaybe<ContactsSumOrderBy>;
  readonly var_pop?: InputMaybe<ContactsVarPopOrderBy>;
  readonly var_samp?: InputMaybe<ContactsVarSampOrderBy>;
  readonly variance?: InputMaybe<ContactsVarianceOrderBy>;
}

/** input type for inserting array relation for remote table "contacts" */
export interface ContactsArrRelInsertInput {
  readonly data: ReadonlyArray<ContactsInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<ContactsOnConflict>;
}

/** aggregate avg on columns */
export interface ContactsAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "contacts" */
export interface ContactsAvgOrderBy {
  readonly id?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "contacts". All fields are combined with a logical 'AND'. */
export interface ContactsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ContactsBoolExp>>;
  readonly _not?: InputMaybe<ContactsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ContactsBoolExp>>;
  readonly company?: InputMaybe<CompaniesBoolExp>;
  readonly company_contacts?: InputMaybe<CompanyContactsBoolExp>;
  readonly company_contacts_aggregate?: InputMaybe<CompanyContactsAggregateBoolExp>;
  readonly company_id?: InputMaybe<UuidComparisonExp>;
  readonly contact_type?: InputMaybe<ContactTypeComparisonExp>;
  readonly created_at?: InputMaybe<TimestampComparisonExp>;
  readonly email?: InputMaybe<StringComparisonExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly is_primary?: InputMaybe<BooleanComparisonExp>;
  readonly phone?: InputMaybe<StringComparisonExp>;
  readonly privacy_level?: InputMaybe<PrivacyLevelComparisonExp>;
  readonly title?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestampComparisonExp>;
  readonly user_id?: InputMaybe<UuidComparisonExp>;
  readonly user_profile?: InputMaybe<UserProfilesBoolExp>;
}

/** unique or primary key constraints on table "contacts" */
export type ContactsConstraint =
  /** unique or primary key constraint on columns "id" */
  "contacts_pkey";

/** input type for incrementing numeric columns in table "contacts" */
export interface ContactsIncInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "contacts" */
export interface ContactsInsertInput {
  readonly company?: InputMaybe<CompaniesObjRelInsertInput>;
  readonly company_contacts?: InputMaybe<CompanyContactsArrRelInsertInput>;
  readonly company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly contact_type?: InputMaybe<Scalars["contact_type"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  readonly email?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly phone?: InputMaybe<Scalars["String"]["input"]>;
  readonly privacy_level?: InputMaybe<Scalars["privacy_level"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
}

/** aggregate max on columns */
export interface ContactsMaxFields {
  readonly company_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly contact_type?: Maybe<Scalars["contact_type"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamp"]["output"]>;
  readonly email?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly phone?: Maybe<Scalars["String"]["output"]>;
  readonly privacy_level?: Maybe<Scalars["privacy_level"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamp"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** order by max() on columns of table "contacts" */
export interface ContactsMaxOrderBy {
  readonly company_id?: InputMaybe<OrderBy>;
  readonly contact_type?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly email?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly phone?: InputMaybe<OrderBy>;
  readonly privacy_level?: InputMaybe<OrderBy>;
  readonly title?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface ContactsMinFields {
  readonly company_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly contact_type?: Maybe<Scalars["contact_type"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamp"]["output"]>;
  readonly email?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly phone?: Maybe<Scalars["String"]["output"]>;
  readonly privacy_level?: Maybe<Scalars["privacy_level"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamp"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** order by min() on columns of table "contacts" */
export interface ContactsMinOrderBy {
  readonly company_id?: InputMaybe<OrderBy>;
  readonly contact_type?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly email?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly phone?: InputMaybe<OrderBy>;
  readonly privacy_level?: InputMaybe<OrderBy>;
  readonly title?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "contacts" */
export interface ContactsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Contacts>;
}

/** input type for inserting object relation for remote table "contacts" */
export interface ContactsObjRelInsertInput {
  readonly data: ContactsInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<ContactsOnConflict>;
}

/** on_conflict condition type for table "contacts" */
export interface ContactsOnConflict {
  readonly constraint: ContactsConstraint;
  readonly update_columns: ReadonlyArray<ContactsUpdateColumn>;
  readonly where?: InputMaybe<ContactsBoolExp>;
}

/** Ordering options when selecting data from "contacts". */
export interface ContactsOrderBy {
  readonly company?: InputMaybe<CompaniesOrderBy>;
  readonly company_contacts_aggregate?: InputMaybe<CompanyContactsAggregateOrderBy>;
  readonly company_id?: InputMaybe<OrderBy>;
  readonly contact_type?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly email?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly is_primary?: InputMaybe<OrderBy>;
  readonly phone?: InputMaybe<OrderBy>;
  readonly privacy_level?: InputMaybe<OrderBy>;
  readonly title?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
  readonly user_profile?: InputMaybe<UserProfilesOrderBy>;
}

/** primary key columns input for table: contacts */
export interface ContactsPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** select columns of table "contacts" */
export type ContactsSelectColumn =
  /** column name */
  | "company_id"
  /** column name */
  | "contact_type"
  /** column name */
  | "created_at"
  /** column name */
  | "email"
  /** column name */
  | "id"
  /** column name */
  | "is_primary"
  /** column name */
  | "phone"
  /** column name */
  | "privacy_level"
  /** column name */
  | "title"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

/** select "contacts_aggregate_bool_exp_bool_and_arguments_columns" columns of table "contacts" */
export type ContactsSelectColumnContactsAggregateBoolExpBoolAndArgumentsColumns =
  /** column name */
  "is_primary";

/** select "contacts_aggregate_bool_exp_bool_or_arguments_columns" columns of table "contacts" */
export type ContactsSelectColumnContactsAggregateBoolExpBoolOrArgumentsColumns =
  /** column name */
  "is_primary";

/** input type for updating data in table "contacts" */
export interface ContactsSetInput {
  readonly company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly contact_type?: InputMaybe<Scalars["contact_type"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  readonly email?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly phone?: InputMaybe<Scalars["String"]["input"]>;
  readonly privacy_level?: InputMaybe<Scalars["privacy_level"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** aggregate stddev on columns */
export interface ContactsStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "contacts" */
export interface ContactsStddevOrderBy {
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface ContactsStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "contacts" */
export interface ContactsStddevPopOrderBy {
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface ContactsStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "contacts" */
export interface ContactsStddevSampOrderBy {
  readonly id?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "contacts" */
export interface ContactsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ContactsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ContactsStreamCursorValueInput {
  readonly company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly contact_type?: InputMaybe<Scalars["contact_type"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  readonly email?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly phone?: InputMaybe<Scalars["String"]["input"]>;
  readonly privacy_level?: InputMaybe<Scalars["privacy_level"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** aggregate sum on columns */
export interface ContactsSumFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
}

/** order by sum() on columns of table "contacts" */
export interface ContactsSumOrderBy {
  readonly id?: InputMaybe<OrderBy>;
}

/** update columns of table "contacts" */
export type ContactsUpdateColumn =
  /** column name */
  | "company_id"
  /** column name */
  | "contact_type"
  /** column name */
  | "created_at"
  /** column name */
  | "email"
  /** column name */
  | "id"
  /** column name */
  | "is_primary"
  /** column name */
  | "phone"
  /** column name */
  | "privacy_level"
  /** column name */
  | "title"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

export interface ContactsUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<ContactsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<ContactsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: ContactsBoolExp;
}

/** aggregate var_pop on columns */
export interface ContactsVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "contacts" */
export interface ContactsVarPopOrderBy {
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface ContactsVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "contacts" */
export interface ContactsVarSampOrderBy {
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface ContactsVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "contacts" */
export interface ContactsVarianceOrderBy {
  readonly id?: InputMaybe<OrderBy>;
}

/** columns and relationships of "content_categories" */
export interface ContentCategories {
  /** An object relationship */
  readonly category: Categories;
  readonly category_id: Scalars["bigint"]["output"];
  /** An object relationship */
  readonly content: Contents;
  readonly content_id: Scalars["uuid"]["output"];
  readonly is_primary: Scalars["Boolean"]["output"];
}

/** aggregated selection of "content_categories" */
export interface ContentCategoriesAggregate {
  readonly aggregate?: Maybe<ContentCategoriesAggregateFields>;
  readonly nodes: ReadonlyArray<ContentCategories>;
}

export interface ContentCategoriesAggregateBoolExp {
  readonly bool_and?: InputMaybe<ContentCategoriesAggregateBoolExpBoolAnd>;
  readonly bool_or?: InputMaybe<ContentCategoriesAggregateBoolExpBoolOr>;
  readonly count?: InputMaybe<ContentCategoriesAggregateBoolExpCount>;
}

export interface ContentCategoriesAggregateBoolExpBoolAnd {
  readonly arguments: ContentCategoriesSelectColumnContentCategoriesAggregateBoolExpBoolAndArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ContentCategoriesBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface ContentCategoriesAggregateBoolExpBoolOr {
  readonly arguments: ContentCategoriesSelectColumnContentCategoriesAggregateBoolExpBoolOrArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ContentCategoriesBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface ContentCategoriesAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<ContentCategoriesSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ContentCategoriesBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "content_categories" */
export interface ContentCategoriesAggregateFields {
  readonly avg?: Maybe<ContentCategoriesAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ContentCategoriesMaxFields>;
  readonly min?: Maybe<ContentCategoriesMinFields>;
  readonly stddev?: Maybe<ContentCategoriesStddevFields>;
  readonly stddev_pop?: Maybe<ContentCategoriesStddevPopFields>;
  readonly stddev_samp?: Maybe<ContentCategoriesStddevSampFields>;
  readonly sum?: Maybe<ContentCategoriesSumFields>;
  readonly var_pop?: Maybe<ContentCategoriesVarPopFields>;
  readonly var_samp?: Maybe<ContentCategoriesVarSampFields>;
  readonly variance?: Maybe<ContentCategoriesVarianceFields>;
}

/** aggregate fields of "content_categories" */
export type ContentCategoriesAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ContentCategoriesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "content_categories" */
export interface ContentCategoriesAggregateOrderBy {
  readonly avg?: InputMaybe<ContentCategoriesAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<ContentCategoriesMaxOrderBy>;
  readonly min?: InputMaybe<ContentCategoriesMinOrderBy>;
  readonly stddev?: InputMaybe<ContentCategoriesStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<ContentCategoriesStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<ContentCategoriesStddevSampOrderBy>;
  readonly sum?: InputMaybe<ContentCategoriesSumOrderBy>;
  readonly var_pop?: InputMaybe<ContentCategoriesVarPopOrderBy>;
  readonly var_samp?: InputMaybe<ContentCategoriesVarSampOrderBy>;
  readonly variance?: InputMaybe<ContentCategoriesVarianceOrderBy>;
}

/** input type for inserting array relation for remote table "content_categories" */
export interface ContentCategoriesArrRelInsertInput {
  readonly data: ReadonlyArray<ContentCategoriesInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<ContentCategoriesOnConflict>;
}

/** aggregate avg on columns */
export interface ContentCategoriesAvgFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "content_categories" */
export interface ContentCategoriesAvgOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "content_categories". All fields are combined with a logical 'AND'. */
export interface ContentCategoriesBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ContentCategoriesBoolExp>>;
  readonly _not?: InputMaybe<ContentCategoriesBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ContentCategoriesBoolExp>>;
  readonly category?: InputMaybe<CategoriesBoolExp>;
  readonly category_id?: InputMaybe<BigintComparisonExp>;
  readonly content?: InputMaybe<ContentsBoolExp>;
  readonly content_id?: InputMaybe<UuidComparisonExp>;
  readonly is_primary?: InputMaybe<BooleanComparisonExp>;
}

/** unique or primary key constraints on table "content_categories" */
export type ContentCategoriesConstraint =
  /** unique or primary key constraint on columns "content_id", "category_id" */
  "content_categories_pkey";

/** input type for incrementing numeric columns in table "content_categories" */
export interface ContentCategoriesIncInput {
  readonly category_id?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** input type for inserting data into table "content_categories" */
export interface ContentCategoriesInsertInput {
  readonly category?: InputMaybe<CategoriesObjRelInsertInput>;
  readonly category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly content?: InputMaybe<ContentsObjRelInsertInput>;
  readonly content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
}

/** aggregate max on columns */
export interface ContentCategoriesMaxFields {
  readonly category_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly content_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** order by max() on columns of table "content_categories" */
export interface ContentCategoriesMaxOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly content_id?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface ContentCategoriesMinFields {
  readonly category_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly content_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** order by min() on columns of table "content_categories" */
export interface ContentCategoriesMinOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly content_id?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "content_categories" */
export interface ContentCategoriesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<ContentCategories>;
}

/** on_conflict condition type for table "content_categories" */
export interface ContentCategoriesOnConflict {
  readonly constraint: ContentCategoriesConstraint;
  readonly update_columns: ReadonlyArray<ContentCategoriesUpdateColumn>;
  readonly where?: InputMaybe<ContentCategoriesBoolExp>;
}

/** Ordering options when selecting data from "content_categories". */
export interface ContentCategoriesOrderBy {
  readonly category?: InputMaybe<CategoriesOrderBy>;
  readonly category_id?: InputMaybe<OrderBy>;
  readonly content?: InputMaybe<ContentsOrderBy>;
  readonly content_id?: InputMaybe<OrderBy>;
  readonly is_primary?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: content_categories */
export interface ContentCategoriesPkColumnsInput {
  readonly category_id: Scalars["bigint"]["input"];
  readonly content_id: Scalars["uuid"]["input"];
}

/** select columns of table "content_categories" */
export type ContentCategoriesSelectColumn =
  /** column name */
  | "category_id"
  /** column name */
  | "content_id"
  /** column name */
  | "is_primary";

/** select "content_categories_aggregate_bool_exp_bool_and_arguments_columns" columns of table "content_categories" */
export type ContentCategoriesSelectColumnContentCategoriesAggregateBoolExpBoolAndArgumentsColumns =
  /** column name */
  "is_primary";

/** select "content_categories_aggregate_bool_exp_bool_or_arguments_columns" columns of table "content_categories" */
export type ContentCategoriesSelectColumnContentCategoriesAggregateBoolExpBoolOrArgumentsColumns =
  /** column name */
  "is_primary";

/** input type for updating data in table "content_categories" */
export interface ContentCategoriesSetInput {
  readonly category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
}

/** aggregate stddev on columns */
export interface ContentCategoriesStddevFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "content_categories" */
export interface ContentCategoriesStddevOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface ContentCategoriesStddevPopFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "content_categories" */
export interface ContentCategoriesStddevPopOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface ContentCategoriesStddevSampFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "content_categories" */
export interface ContentCategoriesStddevSampOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "content_categories" */
export interface ContentCategoriesStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ContentCategoriesStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ContentCategoriesStreamCursorValueInput {
  readonly category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
}

/** aggregate sum on columns */
export interface ContentCategoriesSumFields {
  readonly category_id?: Maybe<Scalars["bigint"]["output"]>;
}

/** order by sum() on columns of table "content_categories" */
export interface ContentCategoriesSumOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
}

/** update columns of table "content_categories" */
export type ContentCategoriesUpdateColumn =
  /** column name */
  | "category_id"
  /** column name */
  | "content_id"
  /** column name */
  | "is_primary";

export interface ContentCategoriesUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<ContentCategoriesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<ContentCategoriesSetInput>;
  /** filter the rows which have to be updated */
  readonly where: ContentCategoriesBoolExp;
}

/** aggregate var_pop on columns */
export interface ContentCategoriesVarPopFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "content_categories" */
export interface ContentCategoriesVarPopOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface ContentCategoriesVarSampFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "content_categories" */
export interface ContentCategoriesVarSampOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface ContentCategoriesVarianceFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "content_categories" */
export interface ContentCategoriesVarianceOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
}

/** columns and relationships of "content_scores" */
export interface ContentScores {
  readonly categories?: Maybe<Scalars["jsonb"]["output"]>;
  readonly content_type?: Maybe<Scalars["content_type"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly hot_score?: Maybe<Scalars["float8"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly status?: Maybe<Scalars["content_status"]["output"]>;
  readonly tags?: Maybe<Scalars["jsonb"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly 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 interface ContentScoresAggregate {
  readonly aggregate?: Maybe<ContentScoresAggregateFields>;
  readonly nodes: ReadonlyArray<ContentScores>;
}

/** aggregate fields of "content_scores" */
export interface ContentScoresAggregateFields {
  readonly avg?: Maybe<ContentScoresAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ContentScoresMaxFields>;
  readonly min?: Maybe<ContentScoresMinFields>;
  readonly stddev?: Maybe<ContentScoresStddevFields>;
  readonly stddev_pop?: Maybe<ContentScoresStddevPopFields>;
  readonly stddev_samp?: Maybe<ContentScoresStddevSampFields>;
  readonly sum?: Maybe<ContentScoresSumFields>;
  readonly var_pop?: Maybe<ContentScoresVarPopFields>;
  readonly var_samp?: Maybe<ContentScoresVarSampFields>;
  readonly variance?: Maybe<ContentScoresVarianceFields>;
}

/** aggregate fields of "content_scores" */
export type ContentScoresAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ContentScoresSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface ContentScoresAvgFields {
  readonly 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 interface ContentScoresBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ContentScoresBoolExp>>;
  readonly _not?: InputMaybe<ContentScoresBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ContentScoresBoolExp>>;
  readonly categories?: InputMaybe<JsonbComparisonExp>;
  readonly content_type?: InputMaybe<ContentTypeComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly hot_score?: InputMaybe<Float8ComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly status?: InputMaybe<ContentStatusComparisonExp>;
  readonly tags?: InputMaybe<JsonbComparisonExp>;
  readonly title?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly url?: InputMaybe<StringComparisonExp>;
}

/** aggregate max on columns */
export interface ContentScoresMaxFields {
  readonly content_type?: Maybe<Scalars["content_type"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly hot_score?: Maybe<Scalars["float8"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly status?: Maybe<Scalars["content_status"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly url?: Maybe<Scalars["String"]["output"]>;
}

/** aggregate min on columns */
export interface ContentScoresMinFields {
  readonly content_type?: Maybe<Scalars["content_type"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly hot_score?: Maybe<Scalars["float8"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly status?: Maybe<Scalars["content_status"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly url?: Maybe<Scalars["String"]["output"]>;
}

/** Ordering options when selecting data from "content_scores". */
export interface ContentScoresOrderBy {
  readonly categories?: InputMaybe<OrderBy>;
  readonly content_type?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly hot_score?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly status?: InputMaybe<OrderBy>;
  readonly tags?: InputMaybe<OrderBy>;
  readonly title?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly url?: InputMaybe<OrderBy>;
}

/** select columns of table "content_scores" */
export type ContentScoresSelectColumn =
  /** column name */
  | "categories"
  /** column name */
  | "content_type"
  /** column name */
  | "created_at"
  /** column name */
  | "hot_score"
  /** column name */
  | "id"
  /** column name */
  | "status"
  /** column name */
  | "tags"
  /** column name */
  | "title"
  /** column name */
  | "updated_at"
  /** column name */
  | "url";

/** aggregate stddev on columns */
export interface ContentScoresStddevFields {
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface ContentScoresStddevPopFields {
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface ContentScoresStddevSampFields {
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "content_scores" */
export interface ContentScoresStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ContentScoresStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ContentScoresStreamCursorValueInput {
  readonly categories?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly hot_score?: InputMaybe<Scalars["float8"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly status?: InputMaybe<Scalars["content_status"]["input"]>;
  readonly tags?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface ContentScoresSumFields {
  readonly hot_score?: Maybe<Scalars["float8"]["output"]>;
}

/** aggregate var_pop on columns */
export interface ContentScoresVarPopFields {
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface ContentScoresVarSampFields {
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface ContentScoresVarianceFields {
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "content_source_visits" */
export interface ContentSourceVisits {
  /** An object relationship */
  readonly content: Contents;
  readonly content_id: Scalars["uuid"]["output"];
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
  /** An object relationship */
  readonly user_profile?: Maybe<UserProfiles>;
}

/** aggregated selection of "content_source_visits" */
export interface ContentSourceVisitsAggregate {
  readonly aggregate?: Maybe<ContentSourceVisitsAggregateFields>;
  readonly nodes: ReadonlyArray<ContentSourceVisits>;
}

export interface ContentSourceVisitsAggregateBoolExp {
  readonly count?: InputMaybe<ContentSourceVisitsAggregateBoolExpCount>;
}

export interface ContentSourceVisitsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<
    ReadonlyArray<ContentSourceVisitsSelectColumn>
  >;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ContentSourceVisitsBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "content_source_visits" */
export interface ContentSourceVisitsAggregateFields {
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ContentSourceVisitsMaxFields>;
  readonly min?: Maybe<ContentSourceVisitsMinFields>;
}

/** aggregate fields of "content_source_visits" */
export type ContentSourceVisitsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ContentSourceVisitsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "content_source_visits" */
export interface ContentSourceVisitsAggregateOrderBy {
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<ContentSourceVisitsMaxOrderBy>;
  readonly min?: InputMaybe<ContentSourceVisitsMinOrderBy>;
}

/** input type for inserting array relation for remote table "content_source_visits" */
export interface ContentSourceVisitsArrRelInsertInput {
  readonly data: ReadonlyArray<ContentSourceVisitsInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<ContentSourceVisitsOnConflict>;
}

/** Boolean expression to filter rows from the table "content_source_visits". All fields are combined with a logical 'AND'. */
export interface ContentSourceVisitsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ContentSourceVisitsBoolExp>>;
  readonly _not?: InputMaybe<ContentSourceVisitsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ContentSourceVisitsBoolExp>>;
  readonly content?: InputMaybe<ContentsBoolExp>;
  readonly content_id?: InputMaybe<UuidComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly user_id?: InputMaybe<UuidComparisonExp>;
  readonly user_profile?: InputMaybe<UserProfilesBoolExp>;
}

/** unique or primary key constraints on table "content_source_visits" */
export type ContentSourceVisitsConstraint =
  /** unique or primary key constraint on columns "id" */
  "content_source_visits_pkey";

/** input type for inserting data into table "content_source_visits" */
export interface ContentSourceVisitsInsertInput {
  readonly content?: InputMaybe<ContentsObjRelInsertInput>;
  readonly content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
}

/** aggregate max on columns */
export interface ContentSourceVisitsMaxFields {
  readonly content_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** order by max() on columns of table "content_source_visits" */
export interface ContentSourceVisitsMaxOrderBy {
  readonly content_id?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface ContentSourceVisitsMinFields {
  readonly content_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** order by min() on columns of table "content_source_visits" */
export interface ContentSourceVisitsMinOrderBy {
  readonly content_id?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "content_source_visits" */
export interface ContentSourceVisitsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<ContentSourceVisits>;
}

/** on_conflict condition type for table "content_source_visits" */
export interface ContentSourceVisitsOnConflict {
  readonly constraint: ContentSourceVisitsConstraint;
  readonly update_columns: ReadonlyArray<ContentSourceVisitsUpdateColumn>;
  readonly where?: InputMaybe<ContentSourceVisitsBoolExp>;
}

/** Ordering options when selecting data from "content_source_visits". */
export interface ContentSourceVisitsOrderBy {
  readonly content?: InputMaybe<ContentsOrderBy>;
  readonly content_id?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
  readonly user_profile?: InputMaybe<UserProfilesOrderBy>;
}

/** primary key columns input for table: content_source_visits */
export interface ContentSourceVisitsPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** select columns of table "content_source_visits" */
export type ContentSourceVisitsSelectColumn =
  /** column name */
  | "content_id"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "user_id";

/** input type for updating data in table "content_source_visits" */
export interface ContentSourceVisitsSetInput {
  readonly content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** Streaming cursor of the table "content_source_visits" */
export interface ContentSourceVisitsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ContentSourceVisitsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ContentSourceVisitsStreamCursorValueInput {
  readonly content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** update columns of table "content_source_visits" */
export type ContentSourceVisitsUpdateColumn =
  /** column name */
  | "content_id"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "user_id";

export interface ContentSourceVisitsUpdates {
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<ContentSourceVisitsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: ContentSourceVisitsBoolExp;
}

/** columns and relationships of "content_sources" */
export interface ContentSources {
  /** An object relationship */
  readonly company?: Maybe<Companies>;
  readonly company_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly content_type: Scalars["content_type"]["output"];
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly expected_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly failed_count?: Maybe<Scalars["smallint"]["output"]>;
  /** An array relationship */
  readonly feed_sources: ReadonlyArray<FeedSources>;
  /** An aggregate relationship */
  readonly feed_sources_aggregate: FeedSourcesAggregate;
  readonly has_failed?: Maybe<Scalars["Boolean"]["output"]>;
  readonly hash?: Maybe<Scalars["bigint"]["output"]>;
  readonly id: Scalars["bigint"]["output"];
  /** An array relationship */
  readonly news: ReadonlyArray<News>;
  /** An aggregate relationship */
  readonly news_aggregate: NewsAggregate;
  readonly priority: Scalars["priority"]["output"];
  readonly refreshed_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly rss_urls?: Maybe<ReadonlyArray<Scalars["String"]["output"]>>;
  readonly scrape_frequency: Scalars["scrape_frequency"]["output"];
  readonly scraped_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly url: Scalars["String"]["output"];
}

/** columns and relationships of "content_sources" */
export type ContentSourcesFeedSourcesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

/** columns and relationships of "content_sources" */
export type ContentSourcesFeedSourcesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

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

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

/** aggregated selection of "content_sources" */
export interface ContentSourcesAggregate {
  readonly aggregate?: Maybe<ContentSourcesAggregateFields>;
  readonly nodes: ReadonlyArray<ContentSources>;
}

export interface ContentSourcesAggregateBoolExp {
  readonly bool_and?: InputMaybe<ContentSourcesAggregateBoolExpBoolAnd>;
  readonly bool_or?: InputMaybe<ContentSourcesAggregateBoolExpBoolOr>;
  readonly count?: InputMaybe<ContentSourcesAggregateBoolExpCount>;
}

export interface ContentSourcesAggregateBoolExpBoolAnd {
  readonly arguments: ContentSourcesSelectColumnContentSourcesAggregateBoolExpBoolAndArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ContentSourcesBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface ContentSourcesAggregateBoolExpBoolOr {
  readonly arguments: ContentSourcesSelectColumnContentSourcesAggregateBoolExpBoolOrArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ContentSourcesBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface ContentSourcesAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<ContentSourcesSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ContentSourcesBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "content_sources" */
export interface ContentSourcesAggregateFields {
  readonly avg?: Maybe<ContentSourcesAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ContentSourcesMaxFields>;
  readonly min?: Maybe<ContentSourcesMinFields>;
  readonly stddev?: Maybe<ContentSourcesStddevFields>;
  readonly stddev_pop?: Maybe<ContentSourcesStddevPopFields>;
  readonly stddev_samp?: Maybe<ContentSourcesStddevSampFields>;
  readonly sum?: Maybe<ContentSourcesSumFields>;
  readonly var_pop?: Maybe<ContentSourcesVarPopFields>;
  readonly var_samp?: Maybe<ContentSourcesVarSampFields>;
  readonly variance?: Maybe<ContentSourcesVarianceFields>;
}

/** aggregate fields of "content_sources" */
export type ContentSourcesAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ContentSourcesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "content_sources" */
export interface ContentSourcesAggregateOrderBy {
  readonly avg?: InputMaybe<ContentSourcesAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<ContentSourcesMaxOrderBy>;
  readonly min?: InputMaybe<ContentSourcesMinOrderBy>;
  readonly stddev?: InputMaybe<ContentSourcesStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<ContentSourcesStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<ContentSourcesStddevSampOrderBy>;
  readonly sum?: InputMaybe<ContentSourcesSumOrderBy>;
  readonly var_pop?: InputMaybe<ContentSourcesVarPopOrderBy>;
  readonly var_samp?: InputMaybe<ContentSourcesVarSampOrderBy>;
  readonly variance?: InputMaybe<ContentSourcesVarianceOrderBy>;
}

/** input type for inserting array relation for remote table "content_sources" */
export interface ContentSourcesArrRelInsertInput {
  readonly data: ReadonlyArray<ContentSourcesInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<ContentSourcesOnConflict>;
}

/** aggregate avg on columns */
export interface ContentSourcesAvgFields {
  readonly expected_count?: Maybe<Scalars["Float"]["output"]>;
  readonly failed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hash?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "content_sources" */
export interface ContentSourcesAvgOrderBy {
  readonly expected_count?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "content_sources". All fields are combined with a logical 'AND'. */
export interface ContentSourcesBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ContentSourcesBoolExp>>;
  readonly _not?: InputMaybe<ContentSourcesBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ContentSourcesBoolExp>>;
  readonly company?: InputMaybe<CompaniesBoolExp>;
  readonly company_id?: InputMaybe<UuidComparisonExp>;
  readonly content_type?: InputMaybe<ContentTypeComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly expected_count?: InputMaybe<SmallintComparisonExp>;
  readonly failed_count?: InputMaybe<SmallintComparisonExp>;
  readonly feed_sources?: InputMaybe<FeedSourcesBoolExp>;
  readonly feed_sources_aggregate?: InputMaybe<FeedSourcesAggregateBoolExp>;
  readonly has_failed?: InputMaybe<BooleanComparisonExp>;
  readonly hash?: InputMaybe<BigintComparisonExp>;
  readonly id?: InputMaybe<BigintComparisonExp>;
  readonly news?: InputMaybe<NewsBoolExp>;
  readonly news_aggregate?: InputMaybe<NewsAggregateBoolExp>;
  readonly priority?: InputMaybe<PriorityComparisonExp>;
  readonly refreshed_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly rss_urls?: InputMaybe<StringArrayComparisonExp>;
  readonly scrape_frequency?: InputMaybe<ScrapeFrequencyComparisonExp>;
  readonly scraped_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly url?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "content_sources" */
export type ContentSourcesConstraint =
  /** unique or primary key constraint on columns "id" */
  | "content_sources_pkey1"
  /** unique or primary key constraint on columns "url" */
  | "content_sources_url_key1";

/** input type for incrementing numeric columns in table "content_sources" */
export interface ContentSourcesIncInput {
  readonly expected_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly hash?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** input type for inserting data into table "content_sources" */
export interface ContentSourcesInsertInput {
  readonly company?: InputMaybe<CompaniesObjRelInsertInput>;
  readonly company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly expected_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly feed_sources?: InputMaybe<FeedSourcesArrRelInsertInput>;
  readonly has_failed?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly hash?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly news?: InputMaybe<NewsArrRelInsertInput>;
  readonly priority?: InputMaybe<Scalars["priority"]["input"]>;
  readonly refreshed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly rss_urls?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
  readonly scrape_frequency?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  readonly scraped_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate max on columns */
export interface ContentSourcesMaxFields {
  readonly company_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly content_type?: Maybe<Scalars["content_type"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly expected_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly failed_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly hash?: Maybe<Scalars["bigint"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly priority?: Maybe<Scalars["priority"]["output"]>;
  readonly refreshed_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly rss_urls?: Maybe<ReadonlyArray<Scalars["String"]["output"]>>;
  readonly scrape_frequency?: Maybe<Scalars["scrape_frequency"]["output"]>;
  readonly scraped_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly url?: Maybe<Scalars["String"]["output"]>;
}

/** order by max() on columns of table "content_sources" */
export interface ContentSourcesMaxOrderBy {
  readonly company_id?: InputMaybe<OrderBy>;
  readonly content_type?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly expected_count?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly priority?: InputMaybe<OrderBy>;
  readonly refreshed_at?: InputMaybe<OrderBy>;
  readonly rss_urls?: InputMaybe<OrderBy>;
  readonly scrape_frequency?: InputMaybe<OrderBy>;
  readonly scraped_at?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly url?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface ContentSourcesMinFields {
  readonly company_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly content_type?: Maybe<Scalars["content_type"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly expected_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly failed_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly hash?: Maybe<Scalars["bigint"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly priority?: Maybe<Scalars["priority"]["output"]>;
  readonly refreshed_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly rss_urls?: Maybe<ReadonlyArray<Scalars["String"]["output"]>>;
  readonly scrape_frequency?: Maybe<Scalars["scrape_frequency"]["output"]>;
  readonly scraped_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly url?: Maybe<Scalars["String"]["output"]>;
}

/** order by min() on columns of table "content_sources" */
export interface ContentSourcesMinOrderBy {
  readonly company_id?: InputMaybe<OrderBy>;
  readonly content_type?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly expected_count?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly priority?: InputMaybe<OrderBy>;
  readonly refreshed_at?: InputMaybe<OrderBy>;
  readonly rss_urls?: InputMaybe<OrderBy>;
  readonly scrape_frequency?: InputMaybe<OrderBy>;
  readonly scraped_at?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly url?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "content_sources" */
export interface ContentSourcesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<ContentSources>;
}

/** input type for inserting object relation for remote table "content_sources" */
export interface ContentSourcesObjRelInsertInput {
  readonly data: ContentSourcesInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<ContentSourcesOnConflict>;
}

/** on_conflict condition type for table "content_sources" */
export interface ContentSourcesOnConflict {
  readonly constraint: ContentSourcesConstraint;
  readonly update_columns: ReadonlyArray<ContentSourcesUpdateColumn>;
  readonly where?: InputMaybe<ContentSourcesBoolExp>;
}

/** Ordering options when selecting data from "content_sources". */
export interface ContentSourcesOrderBy {
  readonly company?: InputMaybe<CompaniesOrderBy>;
  readonly company_id?: InputMaybe<OrderBy>;
  readonly content_type?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly expected_count?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly feed_sources_aggregate?: InputMaybe<FeedSourcesAggregateOrderBy>;
  readonly has_failed?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly news_aggregate?: InputMaybe<NewsAggregateOrderBy>;
  readonly priority?: InputMaybe<OrderBy>;
  readonly refreshed_at?: InputMaybe<OrderBy>;
  readonly rss_urls?: InputMaybe<OrderBy>;
  readonly scrape_frequency?: InputMaybe<OrderBy>;
  readonly scraped_at?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly url?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: content_sources */
export interface ContentSourcesPkColumnsInput {
  readonly id: Scalars["bigint"]["input"];
}

/** select columns of table "content_sources" */
export type ContentSourcesSelectColumn =
  /** column name */
  | "company_id"
  /** column name */
  | "content_type"
  /** column name */
  | "created_at"
  /** column name */
  | "expected_count"
  /** column name */
  | "failed_count"
  /** column name */
  | "has_failed"
  /** column name */
  | "hash"
  /** column name */
  | "id"
  /** column name */
  | "priority"
  /** column name */
  | "refreshed_at"
  /** column name */
  | "rss_urls"
  /** column name */
  | "scrape_frequency"
  /** column name */
  | "scraped_at"
  /** column name */
  | "updated_at"
  /** column name */
  | "url";

/** select "content_sources_aggregate_bool_exp_bool_and_arguments_columns" columns of table "content_sources" */
export type ContentSourcesSelectColumnContentSourcesAggregateBoolExpBoolAndArgumentsColumns =
  /** column name */
  "has_failed";

/** select "content_sources_aggregate_bool_exp_bool_or_arguments_columns" columns of table "content_sources" */
export type ContentSourcesSelectColumnContentSourcesAggregateBoolExpBoolOrArgumentsColumns =
  /** column name */
  "has_failed";

/** input type for updating data in table "content_sources" */
export interface ContentSourcesSetInput {
  readonly company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly expected_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly has_failed?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly hash?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly priority?: InputMaybe<Scalars["priority"]["input"]>;
  readonly refreshed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly rss_urls?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
  readonly scrape_frequency?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  readonly scraped_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate stddev on columns */
export interface ContentSourcesStddevFields {
  readonly expected_count?: Maybe<Scalars["Float"]["output"]>;
  readonly failed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hash?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "content_sources" */
export interface ContentSourcesStddevOrderBy {
  readonly expected_count?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface ContentSourcesStddevPopFields {
  readonly expected_count?: Maybe<Scalars["Float"]["output"]>;
  readonly failed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hash?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "content_sources" */
export interface ContentSourcesStddevPopOrderBy {
  readonly expected_count?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface ContentSourcesStddevSampFields {
  readonly expected_count?: Maybe<Scalars["Float"]["output"]>;
  readonly failed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hash?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "content_sources" */
export interface ContentSourcesStddevSampOrderBy {
  readonly expected_count?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "content_sources" */
export interface ContentSourcesStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ContentSourcesStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ContentSourcesStreamCursorValueInput {
  readonly company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly expected_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly has_failed?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly hash?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly priority?: InputMaybe<Scalars["priority"]["input"]>;
  readonly refreshed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly rss_urls?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
  readonly scrape_frequency?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  readonly scraped_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface ContentSourcesSumFields {
  readonly expected_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly failed_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly hash?: Maybe<Scalars["bigint"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
}

/** order by sum() on columns of table "content_sources" */
export interface ContentSourcesSumOrderBy {
  readonly expected_count?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** update columns of table "content_sources" */
export type ContentSourcesUpdateColumn =
  /** column name */
  | "company_id"
  /** column name */
  | "content_type"
  /** column name */
  | "created_at"
  /** column name */
  | "expected_count"
  /** column name */
  | "failed_count"
  /** column name */
  | "has_failed"
  /** column name */
  | "hash"
  /** column name */
  | "id"
  /** column name */
  | "priority"
  /** column name */
  | "refreshed_at"
  /** column name */
  | "rss_urls"
  /** column name */
  | "scrape_frequency"
  /** column name */
  | "scraped_at"
  /** column name */
  | "updated_at"
  /** column name */
  | "url";

export interface ContentSourcesUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<ContentSourcesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<ContentSourcesSetInput>;
  /** filter the rows which have to be updated */
  readonly where: ContentSourcesBoolExp;
}

/** aggregate var_pop on columns */
export interface ContentSourcesVarPopFields {
  readonly expected_count?: Maybe<Scalars["Float"]["output"]>;
  readonly failed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hash?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "content_sources" */
export interface ContentSourcesVarPopOrderBy {
  readonly expected_count?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface ContentSourcesVarSampFields {
  readonly expected_count?: Maybe<Scalars["Float"]["output"]>;
  readonly failed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hash?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "content_sources" */
export interface ContentSourcesVarSampOrderBy {
  readonly expected_count?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface ContentSourcesVarianceFields {
  readonly expected_count?: Maybe<Scalars["Float"]["output"]>;
  readonly failed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hash?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "content_sources" */
export interface ContentSourcesVarianceOrderBy {
  readonly expected_count?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

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

/** columns and relationships of "content_statuses" */
export interface ContentStatuses {
  /** An object relationship */
  readonly content: Contents;
  readonly content_id: Scalars["uuid"]["output"];
  readonly content_status: Scalars["content_status"]["output"];
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  readonly notes?: Maybe<Scalars["String"]["output"]>;
}

/** aggregated selection of "content_statuses" */
export interface ContentStatusesAggregate {
  readonly aggregate?: Maybe<ContentStatusesAggregateFields>;
  readonly nodes: ReadonlyArray<ContentStatuses>;
}

export interface ContentStatusesAggregateBoolExp {
  readonly count?: InputMaybe<ContentStatusesAggregateBoolExpCount>;
}

export interface ContentStatusesAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<ContentStatusesSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ContentStatusesBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "content_statuses" */
export interface ContentStatusesAggregateFields {
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ContentStatusesMaxFields>;
  readonly min?: Maybe<ContentStatusesMinFields>;
}

/** aggregate fields of "content_statuses" */
export type ContentStatusesAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ContentStatusesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "content_statuses" */
export interface ContentStatusesAggregateOrderBy {
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<ContentStatusesMaxOrderBy>;
  readonly min?: InputMaybe<ContentStatusesMinOrderBy>;
}

/** input type for inserting array relation for remote table "content_statuses" */
export interface ContentStatusesArrRelInsertInput {
  readonly data: ReadonlyArray<ContentStatusesInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<ContentStatusesOnConflict>;
}

/** Boolean expression to filter rows from the table "content_statuses". All fields are combined with a logical 'AND'. */
export interface ContentStatusesBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ContentStatusesBoolExp>>;
  readonly _not?: InputMaybe<ContentStatusesBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ContentStatusesBoolExp>>;
  readonly content?: InputMaybe<ContentsBoolExp>;
  readonly content_id?: InputMaybe<UuidComparisonExp>;
  readonly content_status?: InputMaybe<ContentStatusComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly notes?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "content_statuses" */
export type ContentStatusesConstraint =
  /** unique or primary key constraint on columns "id" */
  "content_statuses_pkey";

/** input type for inserting data into table "content_statuses" */
export interface ContentStatusesInsertInput {
  readonly content?: InputMaybe<ContentsObjRelInsertInput>;
  readonly content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly notes?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate max on columns */
export interface ContentStatusesMaxFields {
  readonly content_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly content_status?: Maybe<Scalars["content_status"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly notes?: Maybe<Scalars["String"]["output"]>;
}

/** order by max() on columns of table "content_statuses" */
export interface ContentStatusesMaxOrderBy {
  readonly content_id?: InputMaybe<OrderBy>;
  readonly content_status?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly notes?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface ContentStatusesMinFields {
  readonly content_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly content_status?: Maybe<Scalars["content_status"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly notes?: Maybe<Scalars["String"]["output"]>;
}

/** order by min() on columns of table "content_statuses" */
export interface ContentStatusesMinOrderBy {
  readonly content_id?: InputMaybe<OrderBy>;
  readonly content_status?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly notes?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "content_statuses" */
export interface ContentStatusesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<ContentStatuses>;
}

/** on_conflict condition type for table "content_statuses" */
export interface ContentStatusesOnConflict {
  readonly constraint: ContentStatusesConstraint;
  readonly update_columns: ReadonlyArray<ContentStatusesUpdateColumn>;
  readonly where?: InputMaybe<ContentStatusesBoolExp>;
}

/** Ordering options when selecting data from "content_statuses". */
export interface ContentStatusesOrderBy {
  readonly content?: InputMaybe<ContentsOrderBy>;
  readonly content_id?: InputMaybe<OrderBy>;
  readonly content_status?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly notes?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: content_statuses */
export interface ContentStatusesPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** select columns of table "content_statuses" */
export type ContentStatusesSelectColumn =
  /** column name */
  | "content_id"
  /** column name */
  | "content_status"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "notes";

/** input type for updating data in table "content_statuses" */
export interface ContentStatusesSetInput {
  readonly content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly notes?: InputMaybe<Scalars["String"]["input"]>;
}

/** Streaming cursor of the table "content_statuses" */
export interface ContentStatusesStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ContentStatusesStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ContentStatusesStreamCursorValueInput {
  readonly content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly notes?: InputMaybe<Scalars["String"]["input"]>;
}

/** update columns of table "content_statuses" */
export type ContentStatusesUpdateColumn =
  /** column name */
  | "content_id"
  /** column name */
  | "content_status"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "notes";

export interface ContentStatusesUpdates {
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<ContentStatusesSetInput>;
  /** filter the rows which have to be updated */
  readonly where: ContentStatusesBoolExp;
}

/** columns and relationships of "content_tags" */
export interface ContentTags {
  /** An object relationship */
  readonly content: Contents;
  readonly content_id: Scalars["uuid"]["output"];
  /** An object relationship */
  readonly tag: Tags;
  readonly tag_id: Scalars["Int"]["output"];
}

/** aggregated selection of "content_tags" */
export interface ContentTagsAggregate {
  readonly aggregate?: Maybe<ContentTagsAggregateFields>;
  readonly nodes: ReadonlyArray<ContentTags>;
}

export interface ContentTagsAggregateBoolExp {
  readonly count?: InputMaybe<ContentTagsAggregateBoolExpCount>;
}

export interface ContentTagsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<ContentTagsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ContentTagsBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "content_tags" */
export interface ContentTagsAggregateFields {
  readonly avg?: Maybe<ContentTagsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ContentTagsMaxFields>;
  readonly min?: Maybe<ContentTagsMinFields>;
  readonly stddev?: Maybe<ContentTagsStddevFields>;
  readonly stddev_pop?: Maybe<ContentTagsStddevPopFields>;
  readonly stddev_samp?: Maybe<ContentTagsStddevSampFields>;
  readonly sum?: Maybe<ContentTagsSumFields>;
  readonly var_pop?: Maybe<ContentTagsVarPopFields>;
  readonly var_samp?: Maybe<ContentTagsVarSampFields>;
  readonly variance?: Maybe<ContentTagsVarianceFields>;
}

/** aggregate fields of "content_tags" */
export type ContentTagsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ContentTagsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "content_tags" */
export interface ContentTagsAggregateOrderBy {
  readonly avg?: InputMaybe<ContentTagsAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<ContentTagsMaxOrderBy>;
  readonly min?: InputMaybe<ContentTagsMinOrderBy>;
  readonly stddev?: InputMaybe<ContentTagsStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<ContentTagsStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<ContentTagsStddevSampOrderBy>;
  readonly sum?: InputMaybe<ContentTagsSumOrderBy>;
  readonly var_pop?: InputMaybe<ContentTagsVarPopOrderBy>;
  readonly var_samp?: InputMaybe<ContentTagsVarSampOrderBy>;
  readonly variance?: InputMaybe<ContentTagsVarianceOrderBy>;
}

/** input type for inserting array relation for remote table "content_tags" */
export interface ContentTagsArrRelInsertInput {
  readonly data: ReadonlyArray<ContentTagsInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<ContentTagsOnConflict>;
}

/** aggregate avg on columns */
export interface ContentTagsAvgFields {
  readonly tag_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "content_tags" */
export interface ContentTagsAvgOrderBy {
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "content_tags". All fields are combined with a logical 'AND'. */
export interface ContentTagsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ContentTagsBoolExp>>;
  readonly _not?: InputMaybe<ContentTagsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ContentTagsBoolExp>>;
  readonly content?: InputMaybe<ContentsBoolExp>;
  readonly content_id?: InputMaybe<UuidComparisonExp>;
  readonly tag?: InputMaybe<TagsBoolExp>;
  readonly tag_id?: InputMaybe<IntComparisonExp>;
}

/** unique or primary key constraints on table "content_tags" */
export type ContentTagsConstraint =
  /** unique or primary key constraint on columns "content_id", "tag_id" */
  "content_tags_pkey";

/** input type for incrementing numeric columns in table "content_tags" */
export interface ContentTagsIncInput {
  readonly tag_id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "content_tags" */
export interface ContentTagsInsertInput {
  readonly content?: InputMaybe<ContentsObjRelInsertInput>;
  readonly content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly tag?: InputMaybe<TagsObjRelInsertInput>;
  readonly tag_id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate max on columns */
export interface ContentTagsMaxFields {
  readonly content_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly tag_id?: Maybe<Scalars["Int"]["output"]>;
}

/** order by max() on columns of table "content_tags" */
export interface ContentTagsMaxOrderBy {
  readonly content_id?: InputMaybe<OrderBy>;
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface ContentTagsMinFields {
  readonly content_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly tag_id?: Maybe<Scalars["Int"]["output"]>;
}

/** order by min() on columns of table "content_tags" */
export interface ContentTagsMinOrderBy {
  readonly content_id?: InputMaybe<OrderBy>;
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "content_tags" */
export interface ContentTagsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<ContentTags>;
}

/** on_conflict condition type for table "content_tags" */
export interface ContentTagsOnConflict {
  readonly constraint: ContentTagsConstraint;
  readonly update_columns: ReadonlyArray<ContentTagsUpdateColumn>;
  readonly where?: InputMaybe<ContentTagsBoolExp>;
}

/** Ordering options when selecting data from "content_tags". */
export interface ContentTagsOrderBy {
  readonly content?: InputMaybe<ContentsOrderBy>;
  readonly content_id?: InputMaybe<OrderBy>;
  readonly tag?: InputMaybe<TagsOrderBy>;
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: content_tags */
export interface ContentTagsPkColumnsInput {
  readonly content_id: Scalars["uuid"]["input"];
  readonly tag_id: Scalars["Int"]["input"];
}

/** select columns of table "content_tags" */
export type ContentTagsSelectColumn =
  /** column name */
  | "content_id"
  /** column name */
  | "tag_id";

/** input type for updating data in table "content_tags" */
export interface ContentTagsSetInput {
  readonly content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly tag_id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate stddev on columns */
export interface ContentTagsStddevFields {
  readonly tag_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "content_tags" */
export interface ContentTagsStddevOrderBy {
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface ContentTagsStddevPopFields {
  readonly tag_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "content_tags" */
export interface ContentTagsStddevPopOrderBy {
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface ContentTagsStddevSampFields {
  readonly tag_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "content_tags" */
export interface ContentTagsStddevSampOrderBy {
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "content_tags" */
export interface ContentTagsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ContentTagsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ContentTagsStreamCursorValueInput {
  readonly content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly tag_id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate sum on columns */
export interface ContentTagsSumFields {
  readonly tag_id?: Maybe<Scalars["Int"]["output"]>;
}

/** order by sum() on columns of table "content_tags" */
export interface ContentTagsSumOrderBy {
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** update columns of table "content_tags" */
export type ContentTagsUpdateColumn =
  /** column name */
  | "content_id"
  /** column name */
  | "tag_id";

export interface ContentTagsUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<ContentTagsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<ContentTagsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: ContentTagsBoolExp;
}

/** aggregate var_pop on columns */
export interface ContentTagsVarPopFields {
  readonly tag_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "content_tags" */
export interface ContentTagsVarPopOrderBy {
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface ContentTagsVarSampFields {
  readonly tag_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "content_tags" */
export interface ContentTagsVarSampOrderBy {
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface ContentTagsVarianceFields {
  readonly tag_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "content_tags" */
export interface ContentTagsVarianceOrderBy {
  readonly tag_id?: InputMaybe<OrderBy>;
}

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

/** columns and relationships of "contents" */
export interface Contents {
  /** An array relationship */
  readonly bookmarks: ReadonlyArray<Bookmarks>;
  /** An aggregate relationship */
  readonly bookmarks_aggregate: BookmarksAggregate;
  /** An array relationship */
  readonly content_categories: ReadonlyArray<ContentCategories>;
  /** An aggregate relationship */
  readonly content_categories_aggregate: ContentCategoriesAggregate;
  /** An array relationship */
  readonly content_source_visits: ReadonlyArray<ContentSourceVisits>;
  /** An aggregate relationship */
  readonly content_source_visits_aggregate: ContentSourceVisitsAggregate;
  /** An array relationship */
  readonly content_statuses: ReadonlyArray<ContentStatuses>;
  /** An aggregate relationship */
  readonly content_statuses_aggregate: ContentStatusesAggregate;
  /** An array relationship */
  readonly content_tags: ReadonlyArray<ContentTags>;
  /** An aggregate relationship */
  readonly content_tags_aggregate: ContentTagsAggregate;
  readonly content_type: Scalars["content_type"]["output"];
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly hot_score?: Maybe<Scalars["float8"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  /** An object relationship */
  readonly news?: Maybe<News>;
  /** An object relationship */
  readonly newsletter?: Maybe<Newsletters>;
  /** An object relationship */
  readonly research?: Maybe<Research>;
  readonly rss_url?: Maybe<Scalars["String"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly url: Scalars["String"]["output"];
}

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

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

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

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

/** columns and relationships of "contents" */
export type ContentsContentSourceVisitsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

/** columns and relationships of "contents" */
export type ContentsContentSourceVisitsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

/** columns and relationships of "contents" */
export type ContentsContentStatusesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentStatusesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentStatusesOrderBy>>;
  where?: InputMaybe<ContentStatusesBoolExp>;
};

/** columns and relationships of "contents" */
export type ContentsContentStatusesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentStatusesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentStatusesOrderBy>>;
  where?: InputMaybe<ContentStatusesBoolExp>;
};

/** columns and relationships of "contents" */
export type ContentsContentTagsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentTagsOrderBy>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

/** columns and relationships of "contents" */
export type ContentsContentTagsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentTagsOrderBy>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

/** aggregated selection of "contents" */
export interface ContentsAggregate {
  readonly aggregate?: Maybe<ContentsAggregateFields>;
  readonly nodes: ReadonlyArray<Contents>;
}

/** aggregate fields of "contents" */
export interface ContentsAggregateFields {
  readonly avg?: Maybe<ContentsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ContentsMaxFields>;
  readonly min?: Maybe<ContentsMinFields>;
  readonly stddev?: Maybe<ContentsStddevFields>;
  readonly stddev_pop?: Maybe<ContentsStddevPopFields>;
  readonly stddev_samp?: Maybe<ContentsStddevSampFields>;
  readonly sum?: Maybe<ContentsSumFields>;
  readonly var_pop?: Maybe<ContentsVarPopFields>;
  readonly var_samp?: Maybe<ContentsVarSampFields>;
  readonly variance?: Maybe<ContentsVarianceFields>;
}

/** aggregate fields of "contents" */
export type ContentsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ContentsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface ContentsAvgFields {
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "contents". All fields are combined with a logical 'AND'. */
export interface ContentsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ContentsBoolExp>>;
  readonly _not?: InputMaybe<ContentsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ContentsBoolExp>>;
  readonly bookmarks?: InputMaybe<BookmarksBoolExp>;
  readonly bookmarks_aggregate?: InputMaybe<BookmarksAggregateBoolExp>;
  readonly content_categories?: InputMaybe<ContentCategoriesBoolExp>;
  readonly content_categories_aggregate?: InputMaybe<ContentCategoriesAggregateBoolExp>;
  readonly content_source_visits?: InputMaybe<ContentSourceVisitsBoolExp>;
  readonly content_source_visits_aggregate?: InputMaybe<ContentSourceVisitsAggregateBoolExp>;
  readonly content_statuses?: InputMaybe<ContentStatusesBoolExp>;
  readonly content_statuses_aggregate?: InputMaybe<ContentStatusesAggregateBoolExp>;
  readonly content_tags?: InputMaybe<ContentTagsBoolExp>;
  readonly content_tags_aggregate?: InputMaybe<ContentTagsAggregateBoolExp>;
  readonly content_type?: InputMaybe<ContentTypeComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly hot_score?: InputMaybe<Float8ComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly news?: InputMaybe<NewsBoolExp>;
  readonly newsletter?: InputMaybe<NewslettersBoolExp>;
  readonly research?: InputMaybe<ResearchBoolExp>;
  readonly rss_url?: InputMaybe<StringComparisonExp>;
  readonly title?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly url?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "contents" */
export type ContentsConstraint =
  /** unique or primary key constraint on columns "id" */
  | "contents_pkey"
  /** unique or primary key constraint on columns "url" */
  | "contents_url_key";

/** input type for incrementing numeric columns in table "contents" */
export interface ContentsIncInput {
  readonly hot_score?: InputMaybe<Scalars["float8"]["input"]>;
}

/** input type for inserting data into table "contents" */
export interface ContentsInsertInput {
  readonly bookmarks?: InputMaybe<BookmarksArrRelInsertInput>;
  readonly content_categories?: InputMaybe<ContentCategoriesArrRelInsertInput>;
  readonly content_source_visits?: InputMaybe<ContentSourceVisitsArrRelInsertInput>;
  readonly content_statuses?: InputMaybe<ContentStatusesArrRelInsertInput>;
  readonly content_tags?: InputMaybe<ContentTagsArrRelInsertInput>;
  readonly content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly hot_score?: InputMaybe<Scalars["float8"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly news?: InputMaybe<NewsObjRelInsertInput>;
  readonly newsletter?: InputMaybe<NewslettersObjRelInsertInput>;
  readonly research?: InputMaybe<ResearchObjRelInsertInput>;
  readonly rss_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate max on columns */
export interface ContentsMaxFields {
  readonly content_type?: Maybe<Scalars["content_type"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly hot_score?: Maybe<Scalars["float8"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly rss_url?: Maybe<Scalars["String"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly url?: Maybe<Scalars["String"]["output"]>;
}

/** aggregate min on columns */
export interface ContentsMinFields {
  readonly content_type?: Maybe<Scalars["content_type"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly hot_score?: Maybe<Scalars["float8"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly rss_url?: Maybe<Scalars["String"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly url?: Maybe<Scalars["String"]["output"]>;
}

/** response of any mutation on the table "contents" */
export interface ContentsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Contents>;
}

/** input type for inserting object relation for remote table "contents" */
export interface ContentsObjRelInsertInput {
  readonly data: ContentsInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<ContentsOnConflict>;
}

/** on_conflict condition type for table "contents" */
export interface ContentsOnConflict {
  readonly constraint: ContentsConstraint;
  readonly update_columns: ReadonlyArray<ContentsUpdateColumn>;
  readonly where?: InputMaybe<ContentsBoolExp>;
}

/** Ordering options when selecting data from "contents". */
export interface ContentsOrderBy {
  readonly bookmarks_aggregate?: InputMaybe<BookmarksAggregateOrderBy>;
  readonly content_categories_aggregate?: InputMaybe<ContentCategoriesAggregateOrderBy>;
  readonly content_source_visits_aggregate?: InputMaybe<ContentSourceVisitsAggregateOrderBy>;
  readonly content_statuses_aggregate?: InputMaybe<ContentStatusesAggregateOrderBy>;
  readonly content_tags_aggregate?: InputMaybe<ContentTagsAggregateOrderBy>;
  readonly content_type?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly hot_score?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly news?: InputMaybe<NewsOrderBy>;
  readonly newsletter?: InputMaybe<NewslettersOrderBy>;
  readonly research?: InputMaybe<ResearchOrderBy>;
  readonly rss_url?: InputMaybe<OrderBy>;
  readonly title?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly url?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: contents */
export interface ContentsPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** select columns of table "contents" */
export type ContentsSelectColumn =
  /** column name */
  | "content_type"
  /** column name */
  | "created_at"
  /** column name */
  | "hot_score"
  /** column name */
  | "id"
  /** column name */
  | "rss_url"
  /** column name */
  | "title"
  /** column name */
  | "updated_at"
  /** column name */
  | "url";

/** input type for updating data in table "contents" */
export interface ContentsSetInput {
  readonly content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly hot_score?: InputMaybe<Scalars["float8"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly rss_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate stddev on columns */
export interface ContentsStddevFields {
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface ContentsStddevPopFields {
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface ContentsStddevSampFields {
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "contents" */
export interface ContentsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ContentsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ContentsStreamCursorValueInput {
  readonly content_type?: InputMaybe<Scalars["content_type"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly hot_score?: InputMaybe<Scalars["float8"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly rss_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface ContentsSumFields {
  readonly hot_score?: Maybe<Scalars["float8"]["output"]>;
}

/** update columns of table "contents" */
export type ContentsUpdateColumn =
  /** column name */
  | "content_type"
  /** column name */
  | "created_at"
  /** column name */
  | "hot_score"
  /** column name */
  | "id"
  /** column name */
  | "rss_url"
  /** column name */
  | "title"
  /** column name */
  | "updated_at"
  /** column name */
  | "url";

export interface ContentsUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<ContentsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<ContentsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: ContentsBoolExp;
}

/** aggregate var_pop on columns */
export interface ContentsVarPopFields {
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface ContentsVarSampFields {
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface ContentsVarianceFields {
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "countries" */
export interface Countries {
  /** An array relationship */
  readonly addresses: ReadonlyArray<Addresses>;
  /** An aggregate relationship */
  readonly addresses_aggregate: AddressesAggregate;
  /** An array relationship */
  readonly cities: ReadonlyArray<Cities>;
  /** An aggregate relationship */
  readonly cities_aggregate: CitiesAggregate;
  readonly code: Scalars["String"]["output"];
  readonly code_3?: Maybe<Scalars["String"]["output"]>;
  readonly id: Scalars["Int"]["output"];
  readonly name: Scalars["String"]["output"];
}

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

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

/** columns and relationships of "countries" */
export type CountriesCitiesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CitiesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CitiesOrderBy>>;
  where?: InputMaybe<CitiesBoolExp>;
};

/** columns and relationships of "countries" */
export type CountriesCitiesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CitiesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CitiesOrderBy>>;
  where?: InputMaybe<CitiesBoolExp>;
};

/** aggregated selection of "countries" */
export interface CountriesAggregate {
  readonly aggregate?: Maybe<CountriesAggregateFields>;
  readonly nodes: ReadonlyArray<Countries>;
}

/** aggregate fields of "countries" */
export interface CountriesAggregateFields {
  readonly avg?: Maybe<CountriesAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<CountriesMaxFields>;
  readonly min?: Maybe<CountriesMinFields>;
  readonly stddev?: Maybe<CountriesStddevFields>;
  readonly stddev_pop?: Maybe<CountriesStddevPopFields>;
  readonly stddev_samp?: Maybe<CountriesStddevSampFields>;
  readonly sum?: Maybe<CountriesSumFields>;
  readonly var_pop?: Maybe<CountriesVarPopFields>;
  readonly var_samp?: Maybe<CountriesVarSampFields>;
  readonly variance?: Maybe<CountriesVarianceFields>;
}

/** aggregate fields of "countries" */
export type CountriesAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<CountriesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface CountriesAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "countries". All fields are combined with a logical 'AND'. */
export interface CountriesBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<CountriesBoolExp>>;
  readonly _not?: InputMaybe<CountriesBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<CountriesBoolExp>>;
  readonly addresses?: InputMaybe<AddressesBoolExp>;
  readonly addresses_aggregate?: InputMaybe<AddressesAggregateBoolExp>;
  readonly cities?: InputMaybe<CitiesBoolExp>;
  readonly cities_aggregate?: InputMaybe<CitiesAggregateBoolExp>;
  readonly code?: InputMaybe<StringComparisonExp>;
  readonly code_3?: InputMaybe<StringComparisonExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly name?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "countries" */
export type CountriesConstraint =
  /** unique or primary key constraint on columns "name" */
  | "countries_name_key"
  /** unique or primary key constraint on columns "id" */
  | "countries_pkey";

/** input type for incrementing numeric columns in table "countries" */
export interface CountriesIncInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "countries" */
export interface CountriesInsertInput {
  readonly addresses?: InputMaybe<AddressesArrRelInsertInput>;
  readonly cities?: InputMaybe<CitiesArrRelInsertInput>;
  readonly code?: InputMaybe<Scalars["String"]["input"]>;
  readonly code_3?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate max on columns */
export interface CountriesMaxFields {
  readonly code?: Maybe<Scalars["String"]["output"]>;
  readonly code_3?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
}

/** aggregate min on columns */
export interface CountriesMinFields {
  readonly code?: Maybe<Scalars["String"]["output"]>;
  readonly code_3?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
}

/** response of any mutation on the table "countries" */
export interface CountriesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Countries>;
}

/** input type for inserting object relation for remote table "countries" */
export interface CountriesObjRelInsertInput {
  readonly data: CountriesInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<CountriesOnConflict>;
}

/** on_conflict condition type for table "countries" */
export interface CountriesOnConflict {
  readonly constraint: CountriesConstraint;
  readonly update_columns: ReadonlyArray<CountriesUpdateColumn>;
  readonly where?: InputMaybe<CountriesBoolExp>;
}

/** Ordering options when selecting data from "countries". */
export interface CountriesOrderBy {
  readonly addresses_aggregate?: InputMaybe<AddressesAggregateOrderBy>;
  readonly cities_aggregate?: InputMaybe<CitiesAggregateOrderBy>;
  readonly code?: InputMaybe<OrderBy>;
  readonly code_3?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly name?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: countries */
export interface CountriesPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** select columns of table "countries" */
export type CountriesSelectColumn =
  /** column name */
  | "code"
  /** column name */
  | "code_3"
  /** column name */
  | "id"
  /** column name */
  | "name";

/** input type for updating data in table "countries" */
export interface CountriesSetInput {
  readonly code?: InputMaybe<Scalars["String"]["input"]>;
  readonly code_3?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate stddev on columns */
export interface CountriesStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface CountriesStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface CountriesStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "countries" */
export interface CountriesStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: CountriesStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface CountriesStreamCursorValueInput {
  readonly code?: InputMaybe<Scalars["String"]["input"]>;
  readonly code_3?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface CountriesSumFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "countries" */
export type CountriesUpdateColumn =
  /** column name */
  | "code"
  /** column name */
  | "code_3"
  /** column name */
  | "id"
  /** column name */
  | "name";

export interface CountriesUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<CountriesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<CountriesSetInput>;
  /** filter the rows which have to be updated */
  readonly where: CountriesBoolExp;
}

/** aggregate var_pop on columns */
export interface CountriesVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface CountriesVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface CountriesVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** ordering argument of a cursor */
export type CursorOrdering =
  /** ascending ordering of the cursor */
  | "ASC"
  /** descending ordering of the cursor */
  | "DESC";

/** columns and relationships of "customer_payments" */
export interface CustomerPayments {
  readonly acquirer_data?: Maybe<Scalars["jsonb"]["output"]>;
  readonly amount: Scalars["numeric"]["output"];
  readonly amount_refunded?: Maybe<Scalars["numeric"]["output"]>;
  readonly amount_transferred?: Maybe<Scalars["numeric"]["output"]>;
  readonly bank?: Maybe<Scalars["String"]["output"]>;
  readonly captured?: Maybe<Scalars["Boolean"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly currency: Scalars["String"]["output"];
  /** An array relationship */
  readonly customer_refunds: ReadonlyArray<CustomerRefunds>;
  /** An aggregate relationship */
  readonly customer_refunds_aggregate: CustomerRefundsAggregate;
  /** An object relationship */
  readonly customer_subscription?: Maybe<CustomerSubscriptions>;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly error_code?: Maybe<Scalars["String"]["output"]>;
  readonly error_description?: Maybe<Scalars["String"]["output"]>;
  readonly error_reason?: Maybe<Scalars["String"]["output"]>;
  readonly error_source?: Maybe<Scalars["String"]["output"]>;
  readonly error_step?: Maybe<Scalars["String"]["output"]>;
  readonly external_order_id?: Maybe<Scalars["String"]["output"]>;
  readonly external_payment_id: Scalars["String"]["output"];
  readonly fee?: Maybe<Scalars["numeric"]["output"]>;
  readonly id: Scalars["Int"]["output"];
  readonly international?: Maybe<Scalars["Boolean"]["output"]>;
  readonly invoice_id?: Maybe<Scalars["String"]["output"]>;
  readonly method?: Maybe<Scalars["String"]["output"]>;
  readonly notes?: Maybe<Scalars["jsonb"]["output"]>;
  readonly order_id?: Maybe<Scalars["String"]["output"]>;
  /** An object relationship */
  readonly payment_provider: PaymentProviders;
  readonly payment_provider_id: Scalars["Int"]["output"];
  readonly refund_status?: Maybe<Scalars["String"]["output"]>;
  readonly status: Scalars["String"]["output"];
  readonly subscription_id?: Maybe<Scalars["Int"]["output"]>;
  readonly tax?: Maybe<Scalars["numeric"]["output"]>;
  readonly user_id: Scalars["uuid"]["output"];
  /** An object relationship */
  readonly user_profile: UserProfiles;
  readonly vpa?: Maybe<Scalars["String"]["output"]>;
  readonly 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<ReadonlyArray<CustomerRefundsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerRefundsOrderBy>>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
};

/** columns and relationships of "customer_payments" */
export type CustomerPaymentsCustomerRefundsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerRefundsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerRefundsOrderBy>>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
};

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

/** aggregated selection of "customer_payments" */
export interface CustomerPaymentsAggregate {
  readonly aggregate?: Maybe<CustomerPaymentsAggregateFields>;
  readonly nodes: ReadonlyArray<CustomerPayments>;
}

export interface CustomerPaymentsAggregateBoolExp {
  readonly bool_and?: InputMaybe<CustomerPaymentsAggregateBoolExpBoolAnd>;
  readonly bool_or?: InputMaybe<CustomerPaymentsAggregateBoolExpBoolOr>;
  readonly count?: InputMaybe<CustomerPaymentsAggregateBoolExpCount>;
}

export interface CustomerPaymentsAggregateBoolExpBoolAnd {
  readonly arguments: CustomerPaymentsSelectColumnCustomerPaymentsAggregateBoolExpBoolAndArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<CustomerPaymentsBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface CustomerPaymentsAggregateBoolExpBoolOr {
  readonly arguments: CustomerPaymentsSelectColumnCustomerPaymentsAggregateBoolExpBoolOrArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<CustomerPaymentsBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface CustomerPaymentsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<CustomerPaymentsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<CustomerPaymentsBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "customer_payments" */
export interface CustomerPaymentsAggregateFields {
  readonly avg?: Maybe<CustomerPaymentsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<CustomerPaymentsMaxFields>;
  readonly min?: Maybe<CustomerPaymentsMinFields>;
  readonly stddev?: Maybe<CustomerPaymentsStddevFields>;
  readonly stddev_pop?: Maybe<CustomerPaymentsStddevPopFields>;
  readonly stddev_samp?: Maybe<CustomerPaymentsStddevSampFields>;
  readonly sum?: Maybe<CustomerPaymentsSumFields>;
  readonly var_pop?: Maybe<CustomerPaymentsVarPopFields>;
  readonly var_samp?: Maybe<CustomerPaymentsVarSampFields>;
  readonly variance?: Maybe<CustomerPaymentsVarianceFields>;
}

/** aggregate fields of "customer_payments" */
export type CustomerPaymentsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<CustomerPaymentsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "customer_payments" */
export interface CustomerPaymentsAggregateOrderBy {
  readonly avg?: InputMaybe<CustomerPaymentsAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<CustomerPaymentsMaxOrderBy>;
  readonly min?: InputMaybe<CustomerPaymentsMinOrderBy>;
  readonly stddev?: InputMaybe<CustomerPaymentsStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<CustomerPaymentsStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<CustomerPaymentsStddevSampOrderBy>;
  readonly sum?: InputMaybe<CustomerPaymentsSumOrderBy>;
  readonly var_pop?: InputMaybe<CustomerPaymentsVarPopOrderBy>;
  readonly var_samp?: InputMaybe<CustomerPaymentsVarSampOrderBy>;
  readonly variance?: InputMaybe<CustomerPaymentsVarianceOrderBy>;
}

/** append existing jsonb value of filtered columns with new jsonb value */
export interface CustomerPaymentsAppendInput {
  readonly acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly notes?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** input type for inserting array relation for remote table "customer_payments" */
export interface CustomerPaymentsArrRelInsertInput {
  readonly data: ReadonlyArray<CustomerPaymentsInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<CustomerPaymentsOnConflict>;
}

/** aggregate avg on columns */
export interface CustomerPaymentsAvgFields {
  readonly amount?: Maybe<Scalars["Float"]["output"]>;
  readonly amount_refunded?: Maybe<Scalars["Float"]["output"]>;
  readonly amount_transferred?: Maybe<Scalars["Float"]["output"]>;
  readonly fee?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  readonly subscription_id?: Maybe<Scalars["Float"]["output"]>;
  readonly tax?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "customer_payments" */
export interface CustomerPaymentsAvgOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly amount_refunded?: InputMaybe<OrderBy>;
  readonly amount_transferred?: InputMaybe<OrderBy>;
  readonly fee?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly subscription_id?: InputMaybe<OrderBy>;
  readonly tax?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "customer_payments". All fields are combined with a logical 'AND'. */
export interface CustomerPaymentsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<CustomerPaymentsBoolExp>>;
  readonly _not?: InputMaybe<CustomerPaymentsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<CustomerPaymentsBoolExp>>;
  readonly acquirer_data?: InputMaybe<JsonbComparisonExp>;
  readonly amount?: InputMaybe<NumericComparisonExp>;
  readonly amount_refunded?: InputMaybe<NumericComparisonExp>;
  readonly amount_transferred?: InputMaybe<NumericComparisonExp>;
  readonly bank?: InputMaybe<StringComparisonExp>;
  readonly captured?: InputMaybe<BooleanComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly currency?: InputMaybe<StringComparisonExp>;
  readonly customer_refunds?: InputMaybe<CustomerRefundsBoolExp>;
  readonly customer_refunds_aggregate?: InputMaybe<CustomerRefundsAggregateBoolExp>;
  readonly customer_subscription?: InputMaybe<CustomerSubscriptionsBoolExp>;
  readonly description?: InputMaybe<StringComparisonExp>;
  readonly error_code?: InputMaybe<StringComparisonExp>;
  readonly error_description?: InputMaybe<StringComparisonExp>;
  readonly error_reason?: InputMaybe<StringComparisonExp>;
  readonly error_source?: InputMaybe<StringComparisonExp>;
  readonly error_step?: InputMaybe<StringComparisonExp>;
  readonly external_order_id?: InputMaybe<StringComparisonExp>;
  readonly external_payment_id?: InputMaybe<StringComparisonExp>;
  readonly fee?: InputMaybe<NumericComparisonExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly international?: InputMaybe<BooleanComparisonExp>;
  readonly invoice_id?: InputMaybe<StringComparisonExp>;
  readonly method?: InputMaybe<StringComparisonExp>;
  readonly notes?: InputMaybe<JsonbComparisonExp>;
  readonly order_id?: InputMaybe<StringComparisonExp>;
  readonly payment_provider?: InputMaybe<PaymentProvidersBoolExp>;
  readonly payment_provider_id?: InputMaybe<IntComparisonExp>;
  readonly refund_status?: InputMaybe<StringComparisonExp>;
  readonly status?: InputMaybe<StringComparisonExp>;
  readonly subscription_id?: InputMaybe<IntComparisonExp>;
  readonly tax?: InputMaybe<NumericComparisonExp>;
  readonly user_id?: InputMaybe<UuidComparisonExp>;
  readonly user_profile?: InputMaybe<UserProfilesBoolExp>;
  readonly vpa?: InputMaybe<StringComparisonExp>;
  readonly wallet?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "customer_payments" */
export type CustomerPaymentsConstraint =
  /** unique or primary key constraint on columns "id" */
  | "customer_payments_pkey"
  /** unique or primary key constraint on columns "external_payment_id" */
  | "uq_payment_id";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface CustomerPaymentsDeleteAtPathInput {
  readonly acquirer_data?: InputMaybe<
    ReadonlyArray<Scalars["String"]["input"]>
  >;
  readonly notes?: InputMaybe<ReadonlyArray<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 interface CustomerPaymentsDeleteElemInput {
  readonly acquirer_data?: InputMaybe<Scalars["Int"]["input"]>;
  readonly notes?: InputMaybe<Scalars["Int"]["input"]>;
}

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export interface CustomerPaymentsDeleteKeyInput {
  readonly acquirer_data?: InputMaybe<Scalars["String"]["input"]>;
  readonly notes?: InputMaybe<Scalars["String"]["input"]>;
}

/** input type for incrementing numeric columns in table "customer_payments" */
export interface CustomerPaymentsIncInput {
  readonly amount?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly amount_refunded?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly amount_transferred?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly fee?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly subscription_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly tax?: InputMaybe<Scalars["numeric"]["input"]>;
}

/** input type for inserting data into table "customer_payments" */
export interface CustomerPaymentsInsertInput {
  readonly acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly amount?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly amount_refunded?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly amount_transferred?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly bank?: InputMaybe<Scalars["String"]["input"]>;
  readonly captured?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly currency?: InputMaybe<Scalars["String"]["input"]>;
  readonly customer_refunds?: InputMaybe<CustomerRefundsArrRelInsertInput>;
  readonly customer_subscription?: InputMaybe<CustomerSubscriptionsObjRelInsertInput>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_code?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_description?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_reason?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_source?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_step?: InputMaybe<Scalars["String"]["input"]>;
  readonly external_order_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly external_payment_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly fee?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly international?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly invoice_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly method?: InputMaybe<Scalars["String"]["input"]>;
  readonly notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly order_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly payment_provider?: InputMaybe<PaymentProvidersObjRelInsertInput>;
  readonly payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly refund_status?: InputMaybe<Scalars["String"]["input"]>;
  readonly status?: InputMaybe<Scalars["String"]["input"]>;
  readonly subscription_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly tax?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
  readonly vpa?: InputMaybe<Scalars["String"]["input"]>;
  readonly wallet?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate max on columns */
export interface CustomerPaymentsMaxFields {
  readonly amount?: Maybe<Scalars["numeric"]["output"]>;
  readonly amount_refunded?: Maybe<Scalars["numeric"]["output"]>;
  readonly amount_transferred?: Maybe<Scalars["numeric"]["output"]>;
  readonly bank?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly currency?: Maybe<Scalars["String"]["output"]>;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly error_code?: Maybe<Scalars["String"]["output"]>;
  readonly error_description?: Maybe<Scalars["String"]["output"]>;
  readonly error_reason?: Maybe<Scalars["String"]["output"]>;
  readonly error_source?: Maybe<Scalars["String"]["output"]>;
  readonly error_step?: Maybe<Scalars["String"]["output"]>;
  readonly external_order_id?: Maybe<Scalars["String"]["output"]>;
  readonly external_payment_id?: Maybe<Scalars["String"]["output"]>;
  readonly fee?: Maybe<Scalars["numeric"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly invoice_id?: Maybe<Scalars["String"]["output"]>;
  readonly method?: Maybe<Scalars["String"]["output"]>;
  readonly order_id?: Maybe<Scalars["String"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Int"]["output"]>;
  readonly refund_status?: Maybe<Scalars["String"]["output"]>;
  readonly status?: Maybe<Scalars["String"]["output"]>;
  readonly subscription_id?: Maybe<Scalars["Int"]["output"]>;
  readonly tax?: Maybe<Scalars["numeric"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly vpa?: Maybe<Scalars["String"]["output"]>;
  readonly wallet?: Maybe<Scalars["String"]["output"]>;
}

/** order by max() on columns of table "customer_payments" */
export interface CustomerPaymentsMaxOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly amount_refunded?: InputMaybe<OrderBy>;
  readonly amount_transferred?: InputMaybe<OrderBy>;
  readonly bank?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly currency?: InputMaybe<OrderBy>;
  readonly description?: InputMaybe<OrderBy>;
  readonly error_code?: InputMaybe<OrderBy>;
  readonly error_description?: InputMaybe<OrderBy>;
  readonly error_reason?: InputMaybe<OrderBy>;
  readonly error_source?: InputMaybe<OrderBy>;
  readonly error_step?: InputMaybe<OrderBy>;
  readonly external_order_id?: InputMaybe<OrderBy>;
  readonly external_payment_id?: InputMaybe<OrderBy>;
  readonly fee?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly invoice_id?: InputMaybe<OrderBy>;
  readonly method?: InputMaybe<OrderBy>;
  readonly order_id?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly refund_status?: InputMaybe<OrderBy>;
  readonly status?: InputMaybe<OrderBy>;
  readonly subscription_id?: InputMaybe<OrderBy>;
  readonly tax?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
  readonly vpa?: InputMaybe<OrderBy>;
  readonly wallet?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface CustomerPaymentsMinFields {
  readonly amount?: Maybe<Scalars["numeric"]["output"]>;
  readonly amount_refunded?: Maybe<Scalars["numeric"]["output"]>;
  readonly amount_transferred?: Maybe<Scalars["numeric"]["output"]>;
  readonly bank?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly currency?: Maybe<Scalars["String"]["output"]>;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly error_code?: Maybe<Scalars["String"]["output"]>;
  readonly error_description?: Maybe<Scalars["String"]["output"]>;
  readonly error_reason?: Maybe<Scalars["String"]["output"]>;
  readonly error_source?: Maybe<Scalars["String"]["output"]>;
  readonly error_step?: Maybe<Scalars["String"]["output"]>;
  readonly external_order_id?: Maybe<Scalars["String"]["output"]>;
  readonly external_payment_id?: Maybe<Scalars["String"]["output"]>;
  readonly fee?: Maybe<Scalars["numeric"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly invoice_id?: Maybe<Scalars["String"]["output"]>;
  readonly method?: Maybe<Scalars["String"]["output"]>;
  readonly order_id?: Maybe<Scalars["String"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Int"]["output"]>;
  readonly refund_status?: Maybe<Scalars["String"]["output"]>;
  readonly status?: Maybe<Scalars["String"]["output"]>;
  readonly subscription_id?: Maybe<Scalars["Int"]["output"]>;
  readonly tax?: Maybe<Scalars["numeric"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly vpa?: Maybe<Scalars["String"]["output"]>;
  readonly wallet?: Maybe<Scalars["String"]["output"]>;
}

/** order by min() on columns of table "customer_payments" */
export interface CustomerPaymentsMinOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly amount_refunded?: InputMaybe<OrderBy>;
  readonly amount_transferred?: InputMaybe<OrderBy>;
  readonly bank?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly currency?: InputMaybe<OrderBy>;
  readonly description?: InputMaybe<OrderBy>;
  readonly error_code?: InputMaybe<OrderBy>;
  readonly error_description?: InputMaybe<OrderBy>;
  readonly error_reason?: InputMaybe<OrderBy>;
  readonly error_source?: InputMaybe<OrderBy>;
  readonly error_step?: InputMaybe<OrderBy>;
  readonly external_order_id?: InputMaybe<OrderBy>;
  readonly external_payment_id?: InputMaybe<OrderBy>;
  readonly fee?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly invoice_id?: InputMaybe<OrderBy>;
  readonly method?: InputMaybe<OrderBy>;
  readonly order_id?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly refund_status?: InputMaybe<OrderBy>;
  readonly status?: InputMaybe<OrderBy>;
  readonly subscription_id?: InputMaybe<OrderBy>;
  readonly tax?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
  readonly vpa?: InputMaybe<OrderBy>;
  readonly wallet?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "customer_payments" */
export interface CustomerPaymentsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<CustomerPayments>;
}

/** input type for inserting object relation for remote table "customer_payments" */
export interface CustomerPaymentsObjRelInsertInput {
  readonly data: CustomerPaymentsInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<CustomerPaymentsOnConflict>;
}

/** on_conflict condition type for table "customer_payments" */
export interface CustomerPaymentsOnConflict {
  readonly constraint: CustomerPaymentsConstraint;
  readonly update_columns: ReadonlyArray<CustomerPaymentsUpdateColumn>;
  readonly where?: InputMaybe<CustomerPaymentsBoolExp>;
}

/** Ordering options when selecting data from "customer_payments". */
export interface CustomerPaymentsOrderBy {
  readonly acquirer_data?: InputMaybe<OrderBy>;
  readonly amount?: InputMaybe<OrderBy>;
  readonly amount_refunded?: InputMaybe<OrderBy>;
  readonly amount_transferred?: InputMaybe<OrderBy>;
  readonly bank?: InputMaybe<OrderBy>;
  readonly captured?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly currency?: InputMaybe<OrderBy>;
  readonly customer_refunds_aggregate?: InputMaybe<CustomerRefundsAggregateOrderBy>;
  readonly customer_subscription?: InputMaybe<CustomerSubscriptionsOrderBy>;
  readonly description?: InputMaybe<OrderBy>;
  readonly error_code?: InputMaybe<OrderBy>;
  readonly error_description?: InputMaybe<OrderBy>;
  readonly error_reason?: InputMaybe<OrderBy>;
  readonly error_source?: InputMaybe<OrderBy>;
  readonly error_step?: InputMaybe<OrderBy>;
  readonly external_order_id?: InputMaybe<OrderBy>;
  readonly external_payment_id?: InputMaybe<OrderBy>;
  readonly fee?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly international?: InputMaybe<OrderBy>;
  readonly invoice_id?: InputMaybe<OrderBy>;
  readonly method?: InputMaybe<OrderBy>;
  readonly notes?: InputMaybe<OrderBy>;
  readonly order_id?: InputMaybe<OrderBy>;
  readonly payment_provider?: InputMaybe<PaymentProvidersOrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly refund_status?: InputMaybe<OrderBy>;
  readonly status?: InputMaybe<OrderBy>;
  readonly subscription_id?: InputMaybe<OrderBy>;
  readonly tax?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
  readonly user_profile?: InputMaybe<UserProfilesOrderBy>;
  readonly vpa?: InputMaybe<OrderBy>;
  readonly wallet?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: customer_payments */
export interface CustomerPaymentsPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** prepend existing jsonb value of filtered columns with new jsonb value */
export interface CustomerPaymentsPrependInput {
  readonly acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly notes?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** select columns of table "customer_payments" */
export type CustomerPaymentsSelectColumn =
  /** column name */
  | "acquirer_data"
  /** column name */
  | "amount"
  /** column name */
  | "amount_refunded"
  /** column name */
  | "amount_transferred"
  /** column name */
  | "bank"
  /** column name */
  | "captured"
  /** column name */
  | "created_at"
  /** column name */
  | "currency"
  /** column name */
  | "description"
  /** column name */
  | "error_code"
  /** column name */
  | "error_description"
  /** column name */
  | "error_reason"
  /** column name */
  | "error_source"
  /** column name */
  | "error_step"
  /** column name */
  | "external_order_id"
  /** column name */
  | "external_payment_id"
  /** column name */
  | "fee"
  /** column name */
  | "id"
  /** column name */
  | "international"
  /** column name */
  | "invoice_id"
  /** column name */
  | "method"
  /** column name */
  | "notes"
  /** column name */
  | "order_id"
  /** column name */
  | "payment_provider_id"
  /** column name */
  | "refund_status"
  /** column name */
  | "status"
  /** column name */
  | "subscription_id"
  /** column name */
  | "tax"
  /** column name */
  | "user_id"
  /** column name */
  | "vpa"
  /** column name */
  | "wallet";

/** select "customer_payments_aggregate_bool_exp_bool_and_arguments_columns" columns of table "customer_payments" */
export type CustomerPaymentsSelectColumnCustomerPaymentsAggregateBoolExpBoolAndArgumentsColumns =
  /** column name */
  | "captured"
  /** column name */
  | "international";

/** select "customer_payments_aggregate_bool_exp_bool_or_arguments_columns" columns of table "customer_payments" */
export type CustomerPaymentsSelectColumnCustomerPaymentsAggregateBoolExpBoolOrArgumentsColumns =
  /** column name */
  | "captured"
  /** column name */
  | "international";

/** input type for updating data in table "customer_payments" */
export interface CustomerPaymentsSetInput {
  readonly acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly amount?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly amount_refunded?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly amount_transferred?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly bank?: InputMaybe<Scalars["String"]["input"]>;
  readonly captured?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly currency?: InputMaybe<Scalars["String"]["input"]>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_code?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_description?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_reason?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_source?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_step?: InputMaybe<Scalars["String"]["input"]>;
  readonly external_order_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly external_payment_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly fee?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly international?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly invoice_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly method?: InputMaybe<Scalars["String"]["input"]>;
  readonly notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly order_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly refund_status?: InputMaybe<Scalars["String"]["input"]>;
  readonly status?: InputMaybe<Scalars["String"]["input"]>;
  readonly subscription_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly tax?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly vpa?: InputMaybe<Scalars["String"]["input"]>;
  readonly wallet?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate stddev on columns */
export interface CustomerPaymentsStddevFields {
  readonly amount?: Maybe<Scalars["Float"]["output"]>;
  readonly amount_refunded?: Maybe<Scalars["Float"]["output"]>;
  readonly amount_transferred?: Maybe<Scalars["Float"]["output"]>;
  readonly fee?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  readonly subscription_id?: Maybe<Scalars["Float"]["output"]>;
  readonly tax?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "customer_payments" */
export interface CustomerPaymentsStddevOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly amount_refunded?: InputMaybe<OrderBy>;
  readonly amount_transferred?: InputMaybe<OrderBy>;
  readonly fee?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly subscription_id?: InputMaybe<OrderBy>;
  readonly tax?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface CustomerPaymentsStddevPopFields {
  readonly amount?: Maybe<Scalars["Float"]["output"]>;
  readonly amount_refunded?: Maybe<Scalars["Float"]["output"]>;
  readonly amount_transferred?: Maybe<Scalars["Float"]["output"]>;
  readonly fee?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  readonly subscription_id?: Maybe<Scalars["Float"]["output"]>;
  readonly tax?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "customer_payments" */
export interface CustomerPaymentsStddevPopOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly amount_refunded?: InputMaybe<OrderBy>;
  readonly amount_transferred?: InputMaybe<OrderBy>;
  readonly fee?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly subscription_id?: InputMaybe<OrderBy>;
  readonly tax?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface CustomerPaymentsStddevSampFields {
  readonly amount?: Maybe<Scalars["Float"]["output"]>;
  readonly amount_refunded?: Maybe<Scalars["Float"]["output"]>;
  readonly amount_transferred?: Maybe<Scalars["Float"]["output"]>;
  readonly fee?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  readonly subscription_id?: Maybe<Scalars["Float"]["output"]>;
  readonly tax?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "customer_payments" */
export interface CustomerPaymentsStddevSampOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly amount_refunded?: InputMaybe<OrderBy>;
  readonly amount_transferred?: InputMaybe<OrderBy>;
  readonly fee?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly subscription_id?: InputMaybe<OrderBy>;
  readonly tax?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "customer_payments" */
export interface CustomerPaymentsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: CustomerPaymentsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface CustomerPaymentsStreamCursorValueInput {
  readonly acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly amount?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly amount_refunded?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly amount_transferred?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly bank?: InputMaybe<Scalars["String"]["input"]>;
  readonly captured?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly currency?: InputMaybe<Scalars["String"]["input"]>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_code?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_description?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_reason?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_source?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_step?: InputMaybe<Scalars["String"]["input"]>;
  readonly external_order_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly external_payment_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly fee?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly international?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly invoice_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly method?: InputMaybe<Scalars["String"]["input"]>;
  readonly notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly order_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly refund_status?: InputMaybe<Scalars["String"]["input"]>;
  readonly status?: InputMaybe<Scalars["String"]["input"]>;
  readonly subscription_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly tax?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly vpa?: InputMaybe<Scalars["String"]["input"]>;
  readonly wallet?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface CustomerPaymentsSumFields {
  readonly amount?: Maybe<Scalars["numeric"]["output"]>;
  readonly amount_refunded?: Maybe<Scalars["numeric"]["output"]>;
  readonly amount_transferred?: Maybe<Scalars["numeric"]["output"]>;
  readonly fee?: Maybe<Scalars["numeric"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Int"]["output"]>;
  readonly subscription_id?: Maybe<Scalars["Int"]["output"]>;
  readonly tax?: Maybe<Scalars["numeric"]["output"]>;
}

/** order by sum() on columns of table "customer_payments" */
export interface CustomerPaymentsSumOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly amount_refunded?: InputMaybe<OrderBy>;
  readonly amount_transferred?: InputMaybe<OrderBy>;
  readonly fee?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly subscription_id?: InputMaybe<OrderBy>;
  readonly tax?: InputMaybe<OrderBy>;
}

/** update columns of table "customer_payments" */
export type CustomerPaymentsUpdateColumn =
  /** column name */
  | "acquirer_data"
  /** column name */
  | "amount"
  /** column name */
  | "amount_refunded"
  /** column name */
  | "amount_transferred"
  /** column name */
  | "bank"
  /** column name */
  | "captured"
  /** column name */
  | "created_at"
  /** column name */
  | "currency"
  /** column name */
  | "description"
  /** column name */
  | "error_code"
  /** column name */
  | "error_description"
  /** column name */
  | "error_reason"
  /** column name */
  | "error_source"
  /** column name */
  | "error_step"
  /** column name */
  | "external_order_id"
  /** column name */
  | "external_payment_id"
  /** column name */
  | "fee"
  /** column name */
  | "id"
  /** column name */
  | "international"
  /** column name */
  | "invoice_id"
  /** column name */
  | "method"
  /** column name */
  | "notes"
  /** column name */
  | "order_id"
  /** column name */
  | "payment_provider_id"
  /** column name */
  | "refund_status"
  /** column name */
  | "status"
  /** column name */
  | "subscription_id"
  /** column name */
  | "tax"
  /** column name */
  | "user_id"
  /** column name */
  | "vpa"
  /** column name */
  | "wallet";

export interface CustomerPaymentsUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<CustomerPaymentsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<CustomerPaymentsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<CustomerPaymentsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<CustomerPaymentsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<CustomerPaymentsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<CustomerPaymentsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: CustomerPaymentsBoolExp;
}

/** aggregate var_pop on columns */
export interface CustomerPaymentsVarPopFields {
  readonly amount?: Maybe<Scalars["Float"]["output"]>;
  readonly amount_refunded?: Maybe<Scalars["Float"]["output"]>;
  readonly amount_transferred?: Maybe<Scalars["Float"]["output"]>;
  readonly fee?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  readonly subscription_id?: Maybe<Scalars["Float"]["output"]>;
  readonly tax?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "customer_payments" */
export interface CustomerPaymentsVarPopOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly amount_refunded?: InputMaybe<OrderBy>;
  readonly amount_transferred?: InputMaybe<OrderBy>;
  readonly fee?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly subscription_id?: InputMaybe<OrderBy>;
  readonly tax?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface CustomerPaymentsVarSampFields {
  readonly amount?: Maybe<Scalars["Float"]["output"]>;
  readonly amount_refunded?: Maybe<Scalars["Float"]["output"]>;
  readonly amount_transferred?: Maybe<Scalars["Float"]["output"]>;
  readonly fee?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  readonly subscription_id?: Maybe<Scalars["Float"]["output"]>;
  readonly tax?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "customer_payments" */
export interface CustomerPaymentsVarSampOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly amount_refunded?: InputMaybe<OrderBy>;
  readonly amount_transferred?: InputMaybe<OrderBy>;
  readonly fee?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly subscription_id?: InputMaybe<OrderBy>;
  readonly tax?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface CustomerPaymentsVarianceFields {
  readonly amount?: Maybe<Scalars["Float"]["output"]>;
  readonly amount_refunded?: Maybe<Scalars["Float"]["output"]>;
  readonly amount_transferred?: Maybe<Scalars["Float"]["output"]>;
  readonly fee?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  readonly subscription_id?: Maybe<Scalars["Float"]["output"]>;
  readonly tax?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "customer_payments" */
export interface CustomerPaymentsVarianceOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly amount_refunded?: InputMaybe<OrderBy>;
  readonly amount_transferred?: InputMaybe<OrderBy>;
  readonly fee?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly subscription_id?: InputMaybe<OrderBy>;
  readonly tax?: InputMaybe<OrderBy>;
}

/** columns and relationships of "customer_processed_webhooks" */
export interface CustomerProcessedWebhooks {
  readonly event_id: Scalars["String"]["output"];
  readonly event_type: Scalars["String"]["output"];
  readonly id: Scalars["Int"]["output"];
  readonly processed_at: Scalars["timestamptz"]["output"];
}

/** aggregated selection of "customer_processed_webhooks" */
export interface CustomerProcessedWebhooksAggregate {
  readonly aggregate?: Maybe<CustomerProcessedWebhooksAggregateFields>;
  readonly nodes: ReadonlyArray<CustomerProcessedWebhooks>;
}

/** aggregate fields of "customer_processed_webhooks" */
export interface CustomerProcessedWebhooksAggregateFields {
  readonly avg?: Maybe<CustomerProcessedWebhooksAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<CustomerProcessedWebhooksMaxFields>;
  readonly min?: Maybe<CustomerProcessedWebhooksMinFields>;
  readonly stddev?: Maybe<CustomerProcessedWebhooksStddevFields>;
  readonly stddev_pop?: Maybe<CustomerProcessedWebhooksStddevPopFields>;
  readonly stddev_samp?: Maybe<CustomerProcessedWebhooksStddevSampFields>;
  readonly sum?: Maybe<CustomerProcessedWebhooksSumFields>;
  readonly var_pop?: Maybe<CustomerProcessedWebhooksVarPopFields>;
  readonly var_samp?: Maybe<CustomerProcessedWebhooksVarSampFields>;
  readonly variance?: Maybe<CustomerProcessedWebhooksVarianceFields>;
}

/** aggregate fields of "customer_processed_webhooks" */
export type CustomerProcessedWebhooksAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<CustomerProcessedWebhooksSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface CustomerProcessedWebhooksAvgFields {
  readonly 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 interface CustomerProcessedWebhooksBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<CustomerProcessedWebhooksBoolExp>>;
  readonly _not?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<CustomerProcessedWebhooksBoolExp>>;
  readonly event_id?: InputMaybe<StringComparisonExp>;
  readonly event_type?: InputMaybe<StringComparisonExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly processed_at?: InputMaybe<TimestamptzComparisonExp>;
}

/** unique or primary key constraints on table "customer_processed_webhooks" */
export type CustomerProcessedWebhooksConstraint =
  /** unique or primary key constraint on columns "event_id" */
  | "customers_processed_webhooks_event_id_key"
  /** unique or primary key constraint on columns "id" */
  | "customers_processed_webhooks_pkey";

/** input type for incrementing numeric columns in table "customer_processed_webhooks" */
export interface CustomerProcessedWebhooksIncInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "customer_processed_webhooks" */
export interface CustomerProcessedWebhooksInsertInput {
  readonly event_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly event_type?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly processed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate max on columns */
export interface CustomerProcessedWebhooksMaxFields {
  readonly event_id?: Maybe<Scalars["String"]["output"]>;
  readonly event_type?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly processed_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** aggregate min on columns */
export interface CustomerProcessedWebhooksMinFields {
  readonly event_id?: Maybe<Scalars["String"]["output"]>;
  readonly event_type?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly processed_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** response of any mutation on the table "customer_processed_webhooks" */
export interface CustomerProcessedWebhooksMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<CustomerProcessedWebhooks>;
}

/** on_conflict condition type for table "customer_processed_webhooks" */
export interface CustomerProcessedWebhooksOnConflict {
  readonly constraint: CustomerProcessedWebhooksConstraint;
  readonly update_columns: ReadonlyArray<CustomerProcessedWebhooksUpdateColumn>;
  readonly where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
}

/** Ordering options when selecting data from "customer_processed_webhooks". */
export interface CustomerProcessedWebhooksOrderBy {
  readonly event_id?: InputMaybe<OrderBy>;
  readonly event_type?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly processed_at?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: customer_processed_webhooks */
export interface CustomerProcessedWebhooksPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** select columns of table "customer_processed_webhooks" */
export type CustomerProcessedWebhooksSelectColumn =
  /** column name */
  | "event_id"
  /** column name */
  | "event_type"
  /** column name */
  | "id"
  /** column name */
  | "processed_at";

/** input type for updating data in table "customer_processed_webhooks" */
export interface CustomerProcessedWebhooksSetInput {
  readonly event_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly event_type?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly processed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate stddev on columns */
export interface CustomerProcessedWebhooksStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface CustomerProcessedWebhooksStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface CustomerProcessedWebhooksStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "customer_processed_webhooks" */
export interface CustomerProcessedWebhooksStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: CustomerProcessedWebhooksStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface CustomerProcessedWebhooksStreamCursorValueInput {
  readonly event_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly event_type?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly processed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate sum on columns */
export interface CustomerProcessedWebhooksSumFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "customer_processed_webhooks" */
export type CustomerProcessedWebhooksUpdateColumn =
  /** column name */
  | "event_id"
  /** column name */
  | "event_type"
  /** column name */
  | "id"
  /** column name */
  | "processed_at";

export interface CustomerProcessedWebhooksUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<CustomerProcessedWebhooksIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<CustomerProcessedWebhooksSetInput>;
  /** filter the rows which have to be updated */
  readonly where: CustomerProcessedWebhooksBoolExp;
}

/** aggregate var_pop on columns */
export interface CustomerProcessedWebhooksVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface CustomerProcessedWebhooksVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface CustomerProcessedWebhooksVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "customer_refunds" */
export interface CustomerRefunds {
  readonly acquirer_data?: Maybe<Scalars["jsonb"]["output"]>;
  readonly amount: Scalars["numeric"]["output"];
  readonly batch_id?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly currency?: Maybe<Scalars["String"]["output"]>;
  /** An object relationship */
  readonly customer_payment: CustomerPayments;
  readonly external_refund_id: Scalars["String"]["output"];
  readonly id: Scalars["Int"]["output"];
  readonly notes?: Maybe<Scalars["jsonb"]["output"]>;
  readonly payment_id: Scalars["Int"]["output"];
  readonly receipt?: Maybe<Scalars["String"]["output"]>;
  readonly speed_processed?: Maybe<Scalars["String"]["output"]>;
  readonly speed_requested?: Maybe<Scalars["String"]["output"]>;
  readonly 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 interface CustomerRefundsAggregate {
  readonly aggregate?: Maybe<CustomerRefundsAggregateFields>;
  readonly nodes: ReadonlyArray<CustomerRefunds>;
}

export interface CustomerRefundsAggregateBoolExp {
  readonly count?: InputMaybe<CustomerRefundsAggregateBoolExpCount>;
}

export interface CustomerRefundsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<CustomerRefundsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<CustomerRefundsBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "customer_refunds" */
export interface CustomerRefundsAggregateFields {
  readonly avg?: Maybe<CustomerRefundsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<CustomerRefundsMaxFields>;
  readonly min?: Maybe<CustomerRefundsMinFields>;
  readonly stddev?: Maybe<CustomerRefundsStddevFields>;
  readonly stddev_pop?: Maybe<CustomerRefundsStddevPopFields>;
  readonly stddev_samp?: Maybe<CustomerRefundsStddevSampFields>;
  readonly sum?: Maybe<CustomerRefundsSumFields>;
  readonly var_pop?: Maybe<CustomerRefundsVarPopFields>;
  readonly var_samp?: Maybe<CustomerRefundsVarSampFields>;
  readonly variance?: Maybe<CustomerRefundsVarianceFields>;
}

/** aggregate fields of "customer_refunds" */
export type CustomerRefundsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<CustomerRefundsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "customer_refunds" */
export interface CustomerRefundsAggregateOrderBy {
  readonly avg?: InputMaybe<CustomerRefundsAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<CustomerRefundsMaxOrderBy>;
  readonly min?: InputMaybe<CustomerRefundsMinOrderBy>;
  readonly stddev?: InputMaybe<CustomerRefundsStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<CustomerRefundsStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<CustomerRefundsStddevSampOrderBy>;
  readonly sum?: InputMaybe<CustomerRefundsSumOrderBy>;
  readonly var_pop?: InputMaybe<CustomerRefundsVarPopOrderBy>;
  readonly var_samp?: InputMaybe<CustomerRefundsVarSampOrderBy>;
  readonly variance?: InputMaybe<CustomerRefundsVarianceOrderBy>;
}

/** append existing jsonb value of filtered columns with new jsonb value */
export interface CustomerRefundsAppendInput {
  readonly acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly notes?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** input type for inserting array relation for remote table "customer_refunds" */
export interface CustomerRefundsArrRelInsertInput {
  readonly data: ReadonlyArray<CustomerRefundsInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<CustomerRefundsOnConflict>;
}

/** aggregate avg on columns */
export interface CustomerRefundsAvgFields {
  readonly amount?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "customer_refunds" */
export interface CustomerRefundsAvgOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_id?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "customer_refunds". All fields are combined with a logical 'AND'. */
export interface CustomerRefundsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<CustomerRefundsBoolExp>>;
  readonly _not?: InputMaybe<CustomerRefundsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<CustomerRefundsBoolExp>>;
  readonly acquirer_data?: InputMaybe<JsonbComparisonExp>;
  readonly amount?: InputMaybe<NumericComparisonExp>;
  readonly batch_id?: InputMaybe<StringComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly currency?: InputMaybe<StringComparisonExp>;
  readonly customer_payment?: InputMaybe<CustomerPaymentsBoolExp>;
  readonly external_refund_id?: InputMaybe<StringComparisonExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly notes?: InputMaybe<JsonbComparisonExp>;
  readonly payment_id?: InputMaybe<IntComparisonExp>;
  readonly receipt?: InputMaybe<StringComparisonExp>;
  readonly speed_processed?: InputMaybe<StringComparisonExp>;
  readonly speed_requested?: InputMaybe<StringComparisonExp>;
  readonly status?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "customer_refunds" */
export type CustomerRefundsConstraint =
  /** unique or primary key constraint on columns "id" */
  "customer_refunds_pkey";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface CustomerRefundsDeleteAtPathInput {
  readonly acquirer_data?: InputMaybe<
    ReadonlyArray<Scalars["String"]["input"]>
  >;
  readonly notes?: InputMaybe<ReadonlyArray<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 interface CustomerRefundsDeleteElemInput {
  readonly acquirer_data?: InputMaybe<Scalars["Int"]["input"]>;
  readonly notes?: InputMaybe<Scalars["Int"]["input"]>;
}

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export interface CustomerRefundsDeleteKeyInput {
  readonly acquirer_data?: InputMaybe<Scalars["String"]["input"]>;
  readonly notes?: InputMaybe<Scalars["String"]["input"]>;
}

/** input type for incrementing numeric columns in table "customer_refunds" */
export interface CustomerRefundsIncInput {
  readonly amount?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly payment_id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "customer_refunds" */
export interface CustomerRefundsInsertInput {
  readonly acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly amount?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly batch_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly currency?: InputMaybe<Scalars["String"]["input"]>;
  readonly customer_payment?: InputMaybe<CustomerPaymentsObjRelInsertInput>;
  readonly external_refund_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly payment_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly receipt?: InputMaybe<Scalars["String"]["input"]>;
  readonly speed_processed?: InputMaybe<Scalars["String"]["input"]>;
  readonly speed_requested?: InputMaybe<Scalars["String"]["input"]>;
  readonly status?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate max on columns */
export interface CustomerRefundsMaxFields {
  readonly amount?: Maybe<Scalars["numeric"]["output"]>;
  readonly batch_id?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly currency?: Maybe<Scalars["String"]["output"]>;
  readonly external_refund_id?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly payment_id?: Maybe<Scalars["Int"]["output"]>;
  readonly receipt?: Maybe<Scalars["String"]["output"]>;
  readonly speed_processed?: Maybe<Scalars["String"]["output"]>;
  readonly speed_requested?: Maybe<Scalars["String"]["output"]>;
  readonly status?: Maybe<Scalars["String"]["output"]>;
}

/** order by max() on columns of table "customer_refunds" */
export interface CustomerRefundsMaxOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly batch_id?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly currency?: InputMaybe<OrderBy>;
  readonly external_refund_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_id?: InputMaybe<OrderBy>;
  readonly receipt?: InputMaybe<OrderBy>;
  readonly speed_processed?: InputMaybe<OrderBy>;
  readonly speed_requested?: InputMaybe<OrderBy>;
  readonly status?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface CustomerRefundsMinFields {
  readonly amount?: Maybe<Scalars["numeric"]["output"]>;
  readonly batch_id?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly currency?: Maybe<Scalars["String"]["output"]>;
  readonly external_refund_id?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly payment_id?: Maybe<Scalars["Int"]["output"]>;
  readonly receipt?: Maybe<Scalars["String"]["output"]>;
  readonly speed_processed?: Maybe<Scalars["String"]["output"]>;
  readonly speed_requested?: Maybe<Scalars["String"]["output"]>;
  readonly status?: Maybe<Scalars["String"]["output"]>;
}

/** order by min() on columns of table "customer_refunds" */
export interface CustomerRefundsMinOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly batch_id?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly currency?: InputMaybe<OrderBy>;
  readonly external_refund_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_id?: InputMaybe<OrderBy>;
  readonly receipt?: InputMaybe<OrderBy>;
  readonly speed_processed?: InputMaybe<OrderBy>;
  readonly speed_requested?: InputMaybe<OrderBy>;
  readonly status?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "customer_refunds" */
export interface CustomerRefundsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<CustomerRefunds>;
}

/** on_conflict condition type for table "customer_refunds" */
export interface CustomerRefundsOnConflict {
  readonly constraint: CustomerRefundsConstraint;
  readonly update_columns: ReadonlyArray<CustomerRefundsUpdateColumn>;
  readonly where?: InputMaybe<CustomerRefundsBoolExp>;
}

/** Ordering options when selecting data from "customer_refunds". */
export interface CustomerRefundsOrderBy {
  readonly acquirer_data?: InputMaybe<OrderBy>;
  readonly amount?: InputMaybe<OrderBy>;
  readonly batch_id?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly currency?: InputMaybe<OrderBy>;
  readonly customer_payment?: InputMaybe<CustomerPaymentsOrderBy>;
  readonly external_refund_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly notes?: InputMaybe<OrderBy>;
  readonly payment_id?: InputMaybe<OrderBy>;
  readonly receipt?: InputMaybe<OrderBy>;
  readonly speed_processed?: InputMaybe<OrderBy>;
  readonly speed_requested?: InputMaybe<OrderBy>;
  readonly status?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: customer_refunds */
export interface CustomerRefundsPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** prepend existing jsonb value of filtered columns with new jsonb value */
export interface CustomerRefundsPrependInput {
  readonly acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly notes?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** select columns of table "customer_refunds" */
export type CustomerRefundsSelectColumn =
  /** column name */
  | "acquirer_data"
  /** column name */
  | "amount"
  /** column name */
  | "batch_id"
  /** column name */
  | "created_at"
  /** column name */
  | "currency"
  /** column name */
  | "external_refund_id"
  /** column name */
  | "id"
  /** column name */
  | "notes"
  /** column name */
  | "payment_id"
  /** column name */
  | "receipt"
  /** column name */
  | "speed_processed"
  /** column name */
  | "speed_requested"
  /** column name */
  | "status";

/** input type for updating data in table "customer_refunds" */
export interface CustomerRefundsSetInput {
  readonly acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly amount?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly batch_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly currency?: InputMaybe<Scalars["String"]["input"]>;
  readonly external_refund_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly payment_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly receipt?: InputMaybe<Scalars["String"]["input"]>;
  readonly speed_processed?: InputMaybe<Scalars["String"]["input"]>;
  readonly speed_requested?: InputMaybe<Scalars["String"]["input"]>;
  readonly status?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate stddev on columns */
export interface CustomerRefundsStddevFields {
  readonly amount?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "customer_refunds" */
export interface CustomerRefundsStddevOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface CustomerRefundsStddevPopFields {
  readonly amount?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "customer_refunds" */
export interface CustomerRefundsStddevPopOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface CustomerRefundsStddevSampFields {
  readonly amount?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "customer_refunds" */
export interface CustomerRefundsStddevSampOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_id?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "customer_refunds" */
export interface CustomerRefundsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: CustomerRefundsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface CustomerRefundsStreamCursorValueInput {
  readonly acquirer_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly amount?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly batch_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly currency?: InputMaybe<Scalars["String"]["input"]>;
  readonly external_refund_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly payment_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly receipt?: InputMaybe<Scalars["String"]["input"]>;
  readonly speed_processed?: InputMaybe<Scalars["String"]["input"]>;
  readonly speed_requested?: InputMaybe<Scalars["String"]["input"]>;
  readonly status?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface CustomerRefundsSumFields {
  readonly amount?: Maybe<Scalars["numeric"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly payment_id?: Maybe<Scalars["Int"]["output"]>;
}

/** order by sum() on columns of table "customer_refunds" */
export interface CustomerRefundsSumOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_id?: InputMaybe<OrderBy>;
}

/** update columns of table "customer_refunds" */
export type CustomerRefundsUpdateColumn =
  /** column name */
  | "acquirer_data"
  /** column name */
  | "amount"
  /** column name */
  | "batch_id"
  /** column name */
  | "created_at"
  /** column name */
  | "currency"
  /** column name */
  | "external_refund_id"
  /** column name */
  | "id"
  /** column name */
  | "notes"
  /** column name */
  | "payment_id"
  /** column name */
  | "receipt"
  /** column name */
  | "speed_processed"
  /** column name */
  | "speed_requested"
  /** column name */
  | "status";

export interface CustomerRefundsUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<CustomerRefundsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<CustomerRefundsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<CustomerRefundsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<CustomerRefundsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<CustomerRefundsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<CustomerRefundsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: CustomerRefundsBoolExp;
}

/** aggregate var_pop on columns */
export interface CustomerRefundsVarPopFields {
  readonly amount?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "customer_refunds" */
export interface CustomerRefundsVarPopOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_id?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface CustomerRefundsVarSampFields {
  readonly amount?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "customer_refunds" */
export interface CustomerRefundsVarSampOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_id?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface CustomerRefundsVarianceFields {
  readonly amount?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "customer_refunds" */
export interface CustomerRefundsVarianceOrderBy {
  readonly amount?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly payment_id?: InputMaybe<OrderBy>;
}

/** columns and relationships of "customer_subscription_plans" */
export interface CustomerSubscriptionPlans {
  readonly annual_amount: Scalars["numeric"]["output"];
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly currency: Scalars["String"]["output"];
  /** An array relationship */
  readonly customer_subscriptions: ReadonlyArray<CustomerSubscriptions>;
  /** An aggregate relationship */
  readonly customer_subscriptions_aggregate: CustomerSubscriptionsAggregate;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly external_plan_id?: Maybe<Scalars["String"]["output"]>;
  readonly features?: Maybe<Scalars["jsonb"]["output"]>;
  readonly id: Scalars["Int"]["output"];
  readonly interval: Scalars["Int"]["output"];
  readonly interval_type: Scalars["String"]["output"];
  readonly is_active?: Maybe<Scalars["Boolean"]["output"]>;
  readonly monthly_amount: Scalars["numeric"]["output"];
  readonly name: Scalars["String"]["output"];
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** columns and relationships of "customer_subscription_plans" */
export type CustomerSubscriptionPlansCustomerSubscriptionsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

/** columns and relationships of "customer_subscription_plans" */
export type CustomerSubscriptionPlansCustomerSubscriptionsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<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 interface CustomerSubscriptionPlansAggregate {
  readonly aggregate?: Maybe<CustomerSubscriptionPlansAggregateFields>;
  readonly nodes: ReadonlyArray<CustomerSubscriptionPlans>;
}

/** aggregate fields of "customer_subscription_plans" */
export interface CustomerSubscriptionPlansAggregateFields {
  readonly avg?: Maybe<CustomerSubscriptionPlansAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<CustomerSubscriptionPlansMaxFields>;
  readonly min?: Maybe<CustomerSubscriptionPlansMinFields>;
  readonly stddev?: Maybe<CustomerSubscriptionPlansStddevFields>;
  readonly stddev_pop?: Maybe<CustomerSubscriptionPlansStddevPopFields>;
  readonly stddev_samp?: Maybe<CustomerSubscriptionPlansStddevSampFields>;
  readonly sum?: Maybe<CustomerSubscriptionPlansSumFields>;
  readonly var_pop?: Maybe<CustomerSubscriptionPlansVarPopFields>;
  readonly var_samp?: Maybe<CustomerSubscriptionPlansVarSampFields>;
  readonly variance?: Maybe<CustomerSubscriptionPlansVarianceFields>;
}

/** aggregate fields of "customer_subscription_plans" */
export type CustomerSubscriptionPlansAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<CustomerSubscriptionPlansSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export interface CustomerSubscriptionPlansAppendInput {
  readonly features?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** aggregate avg on columns */
export interface CustomerSubscriptionPlansAvgFields {
  readonly annual_amount?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly interval?: Maybe<Scalars["Float"]["output"]>;
  readonly 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 interface CustomerSubscriptionPlansBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<CustomerSubscriptionPlansBoolExp>>;
  readonly _not?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<CustomerSubscriptionPlansBoolExp>>;
  readonly annual_amount?: InputMaybe<NumericComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly currency?: InputMaybe<StringComparisonExp>;
  readonly customer_subscriptions?: InputMaybe<CustomerSubscriptionsBoolExp>;
  readonly customer_subscriptions_aggregate?: InputMaybe<CustomerSubscriptionsAggregateBoolExp>;
  readonly description?: InputMaybe<StringComparisonExp>;
  readonly external_plan_id?: InputMaybe<StringComparisonExp>;
  readonly features?: InputMaybe<JsonbComparisonExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly interval?: InputMaybe<IntComparisonExp>;
  readonly interval_type?: InputMaybe<StringComparisonExp>;
  readonly is_active?: InputMaybe<BooleanComparisonExp>;
  readonly monthly_amount?: InputMaybe<NumericComparisonExp>;
  readonly name?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
}

/** unique or primary key constraints on table "customer_subscription_plans" */
export type CustomerSubscriptionPlansConstraint =
  /** unique or primary key constraint on columns "external_plan_id" */
  | "customer_subscription_plans_external_plan_id_key"
  /** unique or primary key constraint on columns "id" */
  | "customer_subscription_plans_pkey";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface CustomerSubscriptionPlansDeleteAtPathInput {
  readonly features?: InputMaybe<ReadonlyArray<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 interface CustomerSubscriptionPlansDeleteElemInput {
  readonly features?: InputMaybe<Scalars["Int"]["input"]>;
}

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

/** input type for incrementing numeric columns in table "customer_subscription_plans" */
export interface CustomerSubscriptionPlansIncInput {
  readonly annual_amount?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly interval?: InputMaybe<Scalars["Int"]["input"]>;
  readonly monthly_amount?: InputMaybe<Scalars["numeric"]["input"]>;
}

/** input type for inserting data into table "customer_subscription_plans" */
export interface CustomerSubscriptionPlansInsertInput {
  readonly annual_amount?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly currency?: InputMaybe<Scalars["String"]["input"]>;
  readonly customer_subscriptions?: InputMaybe<CustomerSubscriptionsArrRelInsertInput>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly external_plan_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly features?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly interval?: InputMaybe<Scalars["Int"]["input"]>;
  readonly interval_type?: InputMaybe<Scalars["String"]["input"]>;
  readonly is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly monthly_amount?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate max on columns */
export interface CustomerSubscriptionPlansMaxFields {
  readonly annual_amount?: Maybe<Scalars["numeric"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly currency?: Maybe<Scalars["String"]["output"]>;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly external_plan_id?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly interval?: Maybe<Scalars["Int"]["output"]>;
  readonly interval_type?: Maybe<Scalars["String"]["output"]>;
  readonly monthly_amount?: Maybe<Scalars["numeric"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** aggregate min on columns */
export interface CustomerSubscriptionPlansMinFields {
  readonly annual_amount?: Maybe<Scalars["numeric"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly currency?: Maybe<Scalars["String"]["output"]>;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly external_plan_id?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly interval?: Maybe<Scalars["Int"]["output"]>;
  readonly interval_type?: Maybe<Scalars["String"]["output"]>;
  readonly monthly_amount?: Maybe<Scalars["numeric"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** response of any mutation on the table "customer_subscription_plans" */
export interface CustomerSubscriptionPlansMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<CustomerSubscriptionPlans>;
}

/** input type for inserting object relation for remote table "customer_subscription_plans" */
export interface CustomerSubscriptionPlansObjRelInsertInput {
  readonly data: CustomerSubscriptionPlansInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<CustomerSubscriptionPlansOnConflict>;
}

/** on_conflict condition type for table "customer_subscription_plans" */
export interface CustomerSubscriptionPlansOnConflict {
  readonly constraint: CustomerSubscriptionPlansConstraint;
  readonly update_columns: ReadonlyArray<CustomerSubscriptionPlansUpdateColumn>;
  readonly where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
}

/** Ordering options when selecting data from "customer_subscription_plans". */
export interface CustomerSubscriptionPlansOrderBy {
  readonly annual_amount?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly currency?: InputMaybe<OrderBy>;
  readonly customer_subscriptions_aggregate?: InputMaybe<CustomerSubscriptionsAggregateOrderBy>;
  readonly description?: InputMaybe<OrderBy>;
  readonly external_plan_id?: InputMaybe<OrderBy>;
  readonly features?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly interval?: InputMaybe<OrderBy>;
  readonly interval_type?: InputMaybe<OrderBy>;
  readonly is_active?: InputMaybe<OrderBy>;
  readonly monthly_amount?: InputMaybe<OrderBy>;
  readonly name?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: customer_subscription_plans */
export interface CustomerSubscriptionPlansPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** prepend existing jsonb value of filtered columns with new jsonb value */
export interface CustomerSubscriptionPlansPrependInput {
  readonly features?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** select columns of table "customer_subscription_plans" */
export type CustomerSubscriptionPlansSelectColumn =
  /** column name */
  | "annual_amount"
  /** column name */
  | "created_at"
  /** column name */
  | "currency"
  /** column name */
  | "description"
  /** column name */
  | "external_plan_id"
  /** column name */
  | "features"
  /** column name */
  | "id"
  /** column name */
  | "interval"
  /** column name */
  | "interval_type"
  /** column name */
  | "is_active"
  /** column name */
  | "monthly_amount"
  /** column name */
  | "name"
  /** column name */
  | "updated_at";

/** input type for updating data in table "customer_subscription_plans" */
export interface CustomerSubscriptionPlansSetInput {
  readonly annual_amount?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly currency?: InputMaybe<Scalars["String"]["input"]>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly external_plan_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly features?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly interval?: InputMaybe<Scalars["Int"]["input"]>;
  readonly interval_type?: InputMaybe<Scalars["String"]["input"]>;
  readonly is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly monthly_amount?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate stddev on columns */
export interface CustomerSubscriptionPlansStddevFields {
  readonly annual_amount?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly interval?: Maybe<Scalars["Float"]["output"]>;
  readonly monthly_amount?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface CustomerSubscriptionPlansStddevPopFields {
  readonly annual_amount?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly interval?: Maybe<Scalars["Float"]["output"]>;
  readonly monthly_amount?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface CustomerSubscriptionPlansStddevSampFields {
  readonly annual_amount?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly interval?: Maybe<Scalars["Float"]["output"]>;
  readonly monthly_amount?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "customer_subscription_plans" */
export interface CustomerSubscriptionPlansStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: CustomerSubscriptionPlansStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface CustomerSubscriptionPlansStreamCursorValueInput {
  readonly annual_amount?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly currency?: InputMaybe<Scalars["String"]["input"]>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly external_plan_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly features?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly interval?: InputMaybe<Scalars["Int"]["input"]>;
  readonly interval_type?: InputMaybe<Scalars["String"]["input"]>;
  readonly is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly monthly_amount?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate sum on columns */
export interface CustomerSubscriptionPlansSumFields {
  readonly annual_amount?: Maybe<Scalars["numeric"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly interval?: Maybe<Scalars["Int"]["output"]>;
  readonly monthly_amount?: Maybe<Scalars["numeric"]["output"]>;
}

/** update columns of table "customer_subscription_plans" */
export type CustomerSubscriptionPlansUpdateColumn =
  /** column name */
  | "annual_amount"
  /** column name */
  | "created_at"
  /** column name */
  | "currency"
  /** column name */
  | "description"
  /** column name */
  | "external_plan_id"
  /** column name */
  | "features"
  /** column name */
  | "id"
  /** column name */
  | "interval"
  /** column name */
  | "interval_type"
  /** column name */
  | "is_active"
  /** column name */
  | "monthly_amount"
  /** column name */
  | "name"
  /** column name */
  | "updated_at";

export interface CustomerSubscriptionPlansUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<CustomerSubscriptionPlansAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<CustomerSubscriptionPlansDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<CustomerSubscriptionPlansDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<CustomerSubscriptionPlansIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<CustomerSubscriptionPlansPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<CustomerSubscriptionPlansSetInput>;
  /** filter the rows which have to be updated */
  readonly where: CustomerSubscriptionPlansBoolExp;
}

/** aggregate var_pop on columns */
export interface CustomerSubscriptionPlansVarPopFields {
  readonly annual_amount?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly interval?: Maybe<Scalars["Float"]["output"]>;
  readonly monthly_amount?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface CustomerSubscriptionPlansVarSampFields {
  readonly annual_amount?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly interval?: Maybe<Scalars["Float"]["output"]>;
  readonly monthly_amount?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface CustomerSubscriptionPlansVarianceFields {
  readonly annual_amount?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly interval?: Maybe<Scalars["Float"]["output"]>;
  readonly monthly_amount?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "customer_subscriptions" */
export interface CustomerSubscriptions {
  readonly auth_attempts?: Maybe<Scalars["Int"]["output"]>;
  readonly cancel_at_period_end?: Maybe<Scalars["Boolean"]["output"]>;
  readonly cancel_initiated_by?: Maybe<Scalars["String"]["output"]>;
  readonly change_scheduled_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly charge_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly current_end: Scalars["timestamptz"]["output"];
  readonly current_start: Scalars["timestamptz"]["output"];
  readonly customer_notify?: Maybe<Scalars["Boolean"]["output"]>;
  /** An array relationship */
  readonly customer_payments: ReadonlyArray<CustomerPayments>;
  /** An aggregate relationship */
  readonly customer_payments_aggregate: CustomerPaymentsAggregate;
  /** An object relationship */
  readonly customer_subscription_plan: CustomerSubscriptionPlans;
  readonly end_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly ended_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly expire_by?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly external_subscription_id: Scalars["String"]["output"];
  readonly has_scheduled_changes?: Maybe<Scalars["Boolean"]["output"]>;
  readonly id: Scalars["Int"]["output"];
  readonly notes?: Maybe<Scalars["jsonb"]["output"]>;
  readonly offer_id?: Maybe<Scalars["String"]["output"]>;
  readonly paid_count?: Maybe<Scalars["Int"]["output"]>;
  readonly pause_initiated_by?: Maybe<Scalars["String"]["output"]>;
  /** An object relationship */
  readonly payment_provider: PaymentProviders;
  readonly payment_provider_id: Scalars["Int"]["output"];
  readonly plan_id: Scalars["Int"]["output"];
  readonly quantity?: Maybe<Scalars["Int"]["output"]>;
  readonly remaining_count?: Maybe<Scalars["Int"]["output"]>;
  readonly short_url?: Maybe<Scalars["String"]["output"]>;
  readonly source?: Maybe<Scalars["String"]["output"]>;
  readonly start_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly status: Scalars["String"]["output"];
  readonly total_count?: Maybe<Scalars["Int"]["output"]>;
  readonly type?: Maybe<Scalars["Int"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly user_id: Scalars["uuid"]["output"];
  /** An object relationship */
  readonly user_profile: UserProfiles;
}

/** columns and relationships of "customer_subscriptions" */
export type CustomerSubscriptionsCustomerPaymentsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

/** columns and relationships of "customer_subscriptions" */
export type CustomerSubscriptionsCustomerPaymentsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

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

/** aggregated selection of "customer_subscriptions" */
export interface CustomerSubscriptionsAggregate {
  readonly aggregate?: Maybe<CustomerSubscriptionsAggregateFields>;
  readonly nodes: ReadonlyArray<CustomerSubscriptions>;
}

export interface CustomerSubscriptionsAggregateBoolExp {
  readonly bool_and?: InputMaybe<CustomerSubscriptionsAggregateBoolExpBoolAnd>;
  readonly bool_or?: InputMaybe<CustomerSubscriptionsAggregateBoolExpBoolOr>;
  readonly count?: InputMaybe<CustomerSubscriptionsAggregateBoolExpCount>;
}

export interface CustomerSubscriptionsAggregateBoolExpBoolAnd {
  readonly arguments: CustomerSubscriptionsSelectColumnCustomerSubscriptionsAggregateBoolExpBoolAndArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<CustomerSubscriptionsBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface CustomerSubscriptionsAggregateBoolExpBoolOr {
  readonly arguments: CustomerSubscriptionsSelectColumnCustomerSubscriptionsAggregateBoolExpBoolOrArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<CustomerSubscriptionsBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface CustomerSubscriptionsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<
    ReadonlyArray<CustomerSubscriptionsSelectColumn>
  >;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<CustomerSubscriptionsBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "customer_subscriptions" */
export interface CustomerSubscriptionsAggregateFields {
  readonly avg?: Maybe<CustomerSubscriptionsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<CustomerSubscriptionsMaxFields>;
  readonly min?: Maybe<CustomerSubscriptionsMinFields>;
  readonly stddev?: Maybe<CustomerSubscriptionsStddevFields>;
  readonly stddev_pop?: Maybe<CustomerSubscriptionsStddevPopFields>;
  readonly stddev_samp?: Maybe<CustomerSubscriptionsStddevSampFields>;
  readonly sum?: Maybe<CustomerSubscriptionsSumFields>;
  readonly var_pop?: Maybe<CustomerSubscriptionsVarPopFields>;
  readonly var_samp?: Maybe<CustomerSubscriptionsVarSampFields>;
  readonly variance?: Maybe<CustomerSubscriptionsVarianceFields>;
}

/** aggregate fields of "customer_subscriptions" */
export type CustomerSubscriptionsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<CustomerSubscriptionsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "customer_subscriptions" */
export interface CustomerSubscriptionsAggregateOrderBy {
  readonly avg?: InputMaybe<CustomerSubscriptionsAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<CustomerSubscriptionsMaxOrderBy>;
  readonly min?: InputMaybe<CustomerSubscriptionsMinOrderBy>;
  readonly stddev?: InputMaybe<CustomerSubscriptionsStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<CustomerSubscriptionsStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<CustomerSubscriptionsStddevSampOrderBy>;
  readonly sum?: InputMaybe<CustomerSubscriptionsSumOrderBy>;
  readonly var_pop?: InputMaybe<CustomerSubscriptionsVarPopOrderBy>;
  readonly var_samp?: InputMaybe<CustomerSubscriptionsVarSampOrderBy>;
  readonly variance?: InputMaybe<CustomerSubscriptionsVarianceOrderBy>;
}

/** append existing jsonb value of filtered columns with new jsonb value */
export interface CustomerSubscriptionsAppendInput {
  readonly notes?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** input type for inserting array relation for remote table "customer_subscriptions" */
export interface CustomerSubscriptionsArrRelInsertInput {
  readonly data: ReadonlyArray<CustomerSubscriptionsInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<CustomerSubscriptionsOnConflict>;
}

/** aggregate avg on columns */
export interface CustomerSubscriptionsAvgFields {
  readonly auth_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly paid_count?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  readonly plan_id?: Maybe<Scalars["Float"]["output"]>;
  readonly quantity?: Maybe<Scalars["Float"]["output"]>;
  readonly remaining_count?: Maybe<Scalars["Float"]["output"]>;
  readonly total_count?: Maybe<Scalars["Float"]["output"]>;
  readonly type?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "customer_subscriptions" */
export interface CustomerSubscriptionsAvgOrderBy {
  readonly auth_attempts?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly paid_count?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly plan_id?: InputMaybe<OrderBy>;
  readonly quantity?: InputMaybe<OrderBy>;
  readonly remaining_count?: InputMaybe<OrderBy>;
  readonly total_count?: InputMaybe<OrderBy>;
  readonly type?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "customer_subscriptions". All fields are combined with a logical 'AND'. */
export interface CustomerSubscriptionsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<CustomerSubscriptionsBoolExp>>;
  readonly _not?: InputMaybe<CustomerSubscriptionsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<CustomerSubscriptionsBoolExp>>;
  readonly auth_attempts?: InputMaybe<IntComparisonExp>;
  readonly cancel_at_period_end?: InputMaybe<BooleanComparisonExp>;
  readonly cancel_initiated_by?: InputMaybe<StringComparisonExp>;
  readonly change_scheduled_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly charge_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly current_end?: InputMaybe<TimestamptzComparisonExp>;
  readonly current_start?: InputMaybe<TimestamptzComparisonExp>;
  readonly customer_notify?: InputMaybe<BooleanComparisonExp>;
  readonly customer_payments?: InputMaybe<CustomerPaymentsBoolExp>;
  readonly customer_payments_aggregate?: InputMaybe<CustomerPaymentsAggregateBoolExp>;
  readonly customer_subscription_plan?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
  readonly end_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly ended_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly expire_by?: InputMaybe<TimestamptzComparisonExp>;
  readonly external_subscription_id?: InputMaybe<StringComparisonExp>;
  readonly has_scheduled_changes?: InputMaybe<BooleanComparisonExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly notes?: InputMaybe<JsonbComparisonExp>;
  readonly offer_id?: InputMaybe<StringComparisonExp>;
  readonly paid_count?: InputMaybe<IntComparisonExp>;
  readonly pause_initiated_by?: InputMaybe<StringComparisonExp>;
  readonly payment_provider?: InputMaybe<PaymentProvidersBoolExp>;
  readonly payment_provider_id?: InputMaybe<IntComparisonExp>;
  readonly plan_id?: InputMaybe<IntComparisonExp>;
  readonly quantity?: InputMaybe<IntComparisonExp>;
  readonly remaining_count?: InputMaybe<IntComparisonExp>;
  readonly short_url?: InputMaybe<StringComparisonExp>;
  readonly source?: InputMaybe<StringComparisonExp>;
  readonly start_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly status?: InputMaybe<StringComparisonExp>;
  readonly total_count?: InputMaybe<IntComparisonExp>;
  readonly type?: InputMaybe<IntComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly user_id?: InputMaybe<UuidComparisonExp>;
  readonly user_profile?: InputMaybe<UserProfilesBoolExp>;
}

/** unique or primary key constraints on table "customer_subscriptions" */
export type CustomerSubscriptionsConstraint =
  /** unique or primary key constraint on columns "id" */
  | "customer_subscriptions_pkey"
  /** unique or primary key constraint on columns "external_subscription_id" */
  | "uq_subscription_id";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface CustomerSubscriptionsDeleteAtPathInput {
  readonly notes?: InputMaybe<ReadonlyArray<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 interface CustomerSubscriptionsDeleteElemInput {
  readonly notes?: InputMaybe<Scalars["Int"]["input"]>;
}

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

/** input type for incrementing numeric columns in table "customer_subscriptions" */
export interface CustomerSubscriptionsIncInput {
  readonly auth_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly paid_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly plan_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly quantity?: InputMaybe<Scalars["Int"]["input"]>;
  readonly remaining_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly total_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly type?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "customer_subscriptions" */
export interface CustomerSubscriptionsInsertInput {
  readonly auth_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  readonly cancel_at_period_end?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly cancel_initiated_by?: InputMaybe<Scalars["String"]["input"]>;
  readonly change_scheduled_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly charge_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly current_end?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly current_start?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly customer_notify?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly customer_payments?: InputMaybe<CustomerPaymentsArrRelInsertInput>;
  readonly customer_subscription_plan?: InputMaybe<CustomerSubscriptionPlansObjRelInsertInput>;
  readonly end_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly ended_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly expire_by?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly external_subscription_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly has_scheduled_changes?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly offer_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly paid_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly pause_initiated_by?: InputMaybe<Scalars["String"]["input"]>;
  readonly payment_provider?: InputMaybe<PaymentProvidersObjRelInsertInput>;
  readonly payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly plan_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly quantity?: InputMaybe<Scalars["Int"]["input"]>;
  readonly remaining_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly short_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly source?: InputMaybe<Scalars["String"]["input"]>;
  readonly start_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly status?: InputMaybe<Scalars["String"]["input"]>;
  readonly total_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly type?: InputMaybe<Scalars["Int"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
}

/** aggregate max on columns */
export interface CustomerSubscriptionsMaxFields {
  readonly auth_attempts?: Maybe<Scalars["Int"]["output"]>;
  readonly cancel_initiated_by?: Maybe<Scalars["String"]["output"]>;
  readonly change_scheduled_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly charge_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly current_end?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly current_start?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly end_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly ended_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly expire_by?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly external_subscription_id?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly offer_id?: Maybe<Scalars["String"]["output"]>;
  readonly paid_count?: Maybe<Scalars["Int"]["output"]>;
  readonly pause_initiated_by?: Maybe<Scalars["String"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Int"]["output"]>;
  readonly plan_id?: Maybe<Scalars["Int"]["output"]>;
  readonly quantity?: Maybe<Scalars["Int"]["output"]>;
  readonly remaining_count?: Maybe<Scalars["Int"]["output"]>;
  readonly short_url?: Maybe<Scalars["String"]["output"]>;
  readonly source?: Maybe<Scalars["String"]["output"]>;
  readonly start_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly status?: Maybe<Scalars["String"]["output"]>;
  readonly total_count?: Maybe<Scalars["Int"]["output"]>;
  readonly type?: Maybe<Scalars["Int"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** order by max() on columns of table "customer_subscriptions" */
export interface CustomerSubscriptionsMaxOrderBy {
  readonly auth_attempts?: InputMaybe<OrderBy>;
  readonly cancel_initiated_by?: InputMaybe<OrderBy>;
  readonly change_scheduled_at?: InputMaybe<OrderBy>;
  readonly charge_at?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly current_end?: InputMaybe<OrderBy>;
  readonly current_start?: InputMaybe<OrderBy>;
  readonly end_at?: InputMaybe<OrderBy>;
  readonly ended_at?: InputMaybe<OrderBy>;
  readonly expire_by?: InputMaybe<OrderBy>;
  readonly external_subscription_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly offer_id?: InputMaybe<OrderBy>;
  readonly paid_count?: InputMaybe<OrderBy>;
  readonly pause_initiated_by?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly plan_id?: InputMaybe<OrderBy>;
  readonly quantity?: InputMaybe<OrderBy>;
  readonly remaining_count?: InputMaybe<OrderBy>;
  readonly short_url?: InputMaybe<OrderBy>;
  readonly source?: InputMaybe<OrderBy>;
  readonly start_at?: InputMaybe<OrderBy>;
  readonly status?: InputMaybe<OrderBy>;
  readonly total_count?: InputMaybe<OrderBy>;
  readonly type?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface CustomerSubscriptionsMinFields {
  readonly auth_attempts?: Maybe<Scalars["Int"]["output"]>;
  readonly cancel_initiated_by?: Maybe<Scalars["String"]["output"]>;
  readonly change_scheduled_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly charge_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly current_end?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly current_start?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly end_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly ended_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly expire_by?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly external_subscription_id?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly offer_id?: Maybe<Scalars["String"]["output"]>;
  readonly paid_count?: Maybe<Scalars["Int"]["output"]>;
  readonly pause_initiated_by?: Maybe<Scalars["String"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Int"]["output"]>;
  readonly plan_id?: Maybe<Scalars["Int"]["output"]>;
  readonly quantity?: Maybe<Scalars["Int"]["output"]>;
  readonly remaining_count?: Maybe<Scalars["Int"]["output"]>;
  readonly short_url?: Maybe<Scalars["String"]["output"]>;
  readonly source?: Maybe<Scalars["String"]["output"]>;
  readonly start_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly status?: Maybe<Scalars["String"]["output"]>;
  readonly total_count?: Maybe<Scalars["Int"]["output"]>;
  readonly type?: Maybe<Scalars["Int"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** order by min() on columns of table "customer_subscriptions" */
export interface CustomerSubscriptionsMinOrderBy {
  readonly auth_attempts?: InputMaybe<OrderBy>;
  readonly cancel_initiated_by?: InputMaybe<OrderBy>;
  readonly change_scheduled_at?: InputMaybe<OrderBy>;
  readonly charge_at?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly current_end?: InputMaybe<OrderBy>;
  readonly current_start?: InputMaybe<OrderBy>;
  readonly end_at?: InputMaybe<OrderBy>;
  readonly ended_at?: InputMaybe<OrderBy>;
  readonly expire_by?: InputMaybe<OrderBy>;
  readonly external_subscription_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly offer_id?: InputMaybe<OrderBy>;
  readonly paid_count?: InputMaybe<OrderBy>;
  readonly pause_initiated_by?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly plan_id?: InputMaybe<OrderBy>;
  readonly quantity?: InputMaybe<OrderBy>;
  readonly remaining_count?: InputMaybe<OrderBy>;
  readonly short_url?: InputMaybe<OrderBy>;
  readonly source?: InputMaybe<OrderBy>;
  readonly start_at?: InputMaybe<OrderBy>;
  readonly status?: InputMaybe<OrderBy>;
  readonly total_count?: InputMaybe<OrderBy>;
  readonly type?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "customer_subscriptions" */
export interface CustomerSubscriptionsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<CustomerSubscriptions>;
}

/** input type for inserting object relation for remote table "customer_subscriptions" */
export interface CustomerSubscriptionsObjRelInsertInput {
  readonly data: CustomerSubscriptionsInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<CustomerSubscriptionsOnConflict>;
}

/** on_conflict condition type for table "customer_subscriptions" */
export interface CustomerSubscriptionsOnConflict {
  readonly constraint: CustomerSubscriptionsConstraint;
  readonly update_columns: ReadonlyArray<CustomerSubscriptionsUpdateColumn>;
  readonly where?: InputMaybe<CustomerSubscriptionsBoolExp>;
}

/** Ordering options when selecting data from "customer_subscriptions". */
export interface CustomerSubscriptionsOrderBy {
  readonly auth_attempts?: InputMaybe<OrderBy>;
  readonly cancel_at_period_end?: InputMaybe<OrderBy>;
  readonly cancel_initiated_by?: InputMaybe<OrderBy>;
  readonly change_scheduled_at?: InputMaybe<OrderBy>;
  readonly charge_at?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly current_end?: InputMaybe<OrderBy>;
  readonly current_start?: InputMaybe<OrderBy>;
  readonly customer_notify?: InputMaybe<OrderBy>;
  readonly customer_payments_aggregate?: InputMaybe<CustomerPaymentsAggregateOrderBy>;
  readonly customer_subscription_plan?: InputMaybe<CustomerSubscriptionPlansOrderBy>;
  readonly end_at?: InputMaybe<OrderBy>;
  readonly ended_at?: InputMaybe<OrderBy>;
  readonly expire_by?: InputMaybe<OrderBy>;
  readonly external_subscription_id?: InputMaybe<OrderBy>;
  readonly has_scheduled_changes?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly notes?: InputMaybe<OrderBy>;
  readonly offer_id?: InputMaybe<OrderBy>;
  readonly paid_count?: InputMaybe<OrderBy>;
  readonly pause_initiated_by?: InputMaybe<OrderBy>;
  readonly payment_provider?: InputMaybe<PaymentProvidersOrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly plan_id?: InputMaybe<OrderBy>;
  readonly quantity?: InputMaybe<OrderBy>;
  readonly remaining_count?: InputMaybe<OrderBy>;
  readonly short_url?: InputMaybe<OrderBy>;
  readonly source?: InputMaybe<OrderBy>;
  readonly start_at?: InputMaybe<OrderBy>;
  readonly status?: InputMaybe<OrderBy>;
  readonly total_count?: InputMaybe<OrderBy>;
  readonly type?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
  readonly user_profile?: InputMaybe<UserProfilesOrderBy>;
}

/** primary key columns input for table: customer_subscriptions */
export interface CustomerSubscriptionsPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** prepend existing jsonb value of filtered columns with new jsonb value */
export interface CustomerSubscriptionsPrependInput {
  readonly notes?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** select columns of table "customer_subscriptions" */
export type CustomerSubscriptionsSelectColumn =
  /** column name */
  | "auth_attempts"
  /** column name */
  | "cancel_at_period_end"
  /** column name */
  | "cancel_initiated_by"
  /** column name */
  | "change_scheduled_at"
  /** column name */
  | "charge_at"
  /** column name */
  | "created_at"
  /** column name */
  | "current_end"
  /** column name */
  | "current_start"
  /** column name */
  | "customer_notify"
  /** column name */
  | "end_at"
  /** column name */
  | "ended_at"
  /** column name */
  | "expire_by"
  /** column name */
  | "external_subscription_id"
  /** column name */
  | "has_scheduled_changes"
  /** column name */
  | "id"
  /** column name */
  | "notes"
  /** column name */
  | "offer_id"
  /** column name */
  | "paid_count"
  /** column name */
  | "pause_initiated_by"
  /** column name */
  | "payment_provider_id"
  /** column name */
  | "plan_id"
  /** column name */
  | "quantity"
  /** column name */
  | "remaining_count"
  /** column name */
  | "short_url"
  /** column name */
  | "source"
  /** column name */
  | "start_at"
  /** column name */
  | "status"
  /** column name */
  | "total_count"
  /** column name */
  | "type"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

/** select "customer_subscriptions_aggregate_bool_exp_bool_and_arguments_columns" columns of table "customer_subscriptions" */
export type CustomerSubscriptionsSelectColumnCustomerSubscriptionsAggregateBoolExpBoolAndArgumentsColumns =
  /** column name */
  | "cancel_at_period_end"
  /** column name */
  | "customer_notify"
  /** column name */
  | "has_scheduled_changes";

/** select "customer_subscriptions_aggregate_bool_exp_bool_or_arguments_columns" columns of table "customer_subscriptions" */
export type CustomerSubscriptionsSelectColumnCustomerSubscriptionsAggregateBoolExpBoolOrArgumentsColumns =
  /** column name */
  | "cancel_at_period_end"
  /** column name */
  | "customer_notify"
  /** column name */
  | "has_scheduled_changes";

/** input type for updating data in table "customer_subscriptions" */
export interface CustomerSubscriptionsSetInput {
  readonly auth_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  readonly cancel_at_period_end?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly cancel_initiated_by?: InputMaybe<Scalars["String"]["input"]>;
  readonly change_scheduled_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly charge_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly current_end?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly current_start?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly customer_notify?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly end_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly ended_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly expire_by?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly external_subscription_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly has_scheduled_changes?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly offer_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly paid_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly pause_initiated_by?: InputMaybe<Scalars["String"]["input"]>;
  readonly payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly plan_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly quantity?: InputMaybe<Scalars["Int"]["input"]>;
  readonly remaining_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly short_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly source?: InputMaybe<Scalars["String"]["input"]>;
  readonly start_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly status?: InputMaybe<Scalars["String"]["input"]>;
  readonly total_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly type?: InputMaybe<Scalars["Int"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** aggregate stddev on columns */
export interface CustomerSubscriptionsStddevFields {
  readonly auth_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly paid_count?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  readonly plan_id?: Maybe<Scalars["Float"]["output"]>;
  readonly quantity?: Maybe<Scalars["Float"]["output"]>;
  readonly remaining_count?: Maybe<Scalars["Float"]["output"]>;
  readonly total_count?: Maybe<Scalars["Float"]["output"]>;
  readonly type?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "customer_subscriptions" */
export interface CustomerSubscriptionsStddevOrderBy {
  readonly auth_attempts?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly paid_count?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly plan_id?: InputMaybe<OrderBy>;
  readonly quantity?: InputMaybe<OrderBy>;
  readonly remaining_count?: InputMaybe<OrderBy>;
  readonly total_count?: InputMaybe<OrderBy>;
  readonly type?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface CustomerSubscriptionsStddevPopFields {
  readonly auth_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly paid_count?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  readonly plan_id?: Maybe<Scalars["Float"]["output"]>;
  readonly quantity?: Maybe<Scalars["Float"]["output"]>;
  readonly remaining_count?: Maybe<Scalars["Float"]["output"]>;
  readonly total_count?: Maybe<Scalars["Float"]["output"]>;
  readonly type?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "customer_subscriptions" */
export interface CustomerSubscriptionsStddevPopOrderBy {
  readonly auth_attempts?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly paid_count?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly plan_id?: InputMaybe<OrderBy>;
  readonly quantity?: InputMaybe<OrderBy>;
  readonly remaining_count?: InputMaybe<OrderBy>;
  readonly total_count?: InputMaybe<OrderBy>;
  readonly type?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface CustomerSubscriptionsStddevSampFields {
  readonly auth_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly paid_count?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  readonly plan_id?: Maybe<Scalars["Float"]["output"]>;
  readonly quantity?: Maybe<Scalars["Float"]["output"]>;
  readonly remaining_count?: Maybe<Scalars["Float"]["output"]>;
  readonly total_count?: Maybe<Scalars["Float"]["output"]>;
  readonly type?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "customer_subscriptions" */
export interface CustomerSubscriptionsStddevSampOrderBy {
  readonly auth_attempts?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly paid_count?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly plan_id?: InputMaybe<OrderBy>;
  readonly quantity?: InputMaybe<OrderBy>;
  readonly remaining_count?: InputMaybe<OrderBy>;
  readonly total_count?: InputMaybe<OrderBy>;
  readonly type?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "customer_subscriptions" */
export interface CustomerSubscriptionsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: CustomerSubscriptionsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface CustomerSubscriptionsStreamCursorValueInput {
  readonly auth_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  readonly cancel_at_period_end?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly cancel_initiated_by?: InputMaybe<Scalars["String"]["input"]>;
  readonly change_scheduled_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly charge_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly current_end?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly current_start?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly customer_notify?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly end_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly ended_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly expire_by?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly external_subscription_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly has_scheduled_changes?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly notes?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly offer_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly paid_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly pause_initiated_by?: InputMaybe<Scalars["String"]["input"]>;
  readonly payment_provider_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly plan_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly quantity?: InputMaybe<Scalars["Int"]["input"]>;
  readonly remaining_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly short_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly source?: InputMaybe<Scalars["String"]["input"]>;
  readonly start_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly status?: InputMaybe<Scalars["String"]["input"]>;
  readonly total_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly type?: InputMaybe<Scalars["Int"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** aggregate sum on columns */
export interface CustomerSubscriptionsSumFields {
  readonly auth_attempts?: Maybe<Scalars["Int"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly paid_count?: Maybe<Scalars["Int"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Int"]["output"]>;
  readonly plan_id?: Maybe<Scalars["Int"]["output"]>;
  readonly quantity?: Maybe<Scalars["Int"]["output"]>;
  readonly remaining_count?: Maybe<Scalars["Int"]["output"]>;
  readonly total_count?: Maybe<Scalars["Int"]["output"]>;
  readonly type?: Maybe<Scalars["Int"]["output"]>;
}

/** order by sum() on columns of table "customer_subscriptions" */
export interface CustomerSubscriptionsSumOrderBy {
  readonly auth_attempts?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly paid_count?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly plan_id?: InputMaybe<OrderBy>;
  readonly quantity?: InputMaybe<OrderBy>;
  readonly remaining_count?: InputMaybe<OrderBy>;
  readonly total_count?: InputMaybe<OrderBy>;
  readonly type?: InputMaybe<OrderBy>;
}

/** update columns of table "customer_subscriptions" */
export type CustomerSubscriptionsUpdateColumn =
  /** column name */
  | "auth_attempts"
  /** column name */
  | "cancel_at_period_end"
  /** column name */
  | "cancel_initiated_by"
  /** column name */
  | "change_scheduled_at"
  /** column name */
  | "charge_at"
  /** column name */
  | "created_at"
  /** column name */
  | "current_end"
  /** column name */
  | "current_start"
  /** column name */
  | "customer_notify"
  /** column name */
  | "end_at"
  /** column name */
  | "ended_at"
  /** column name */
  | "expire_by"
  /** column name */
  | "external_subscription_id"
  /** column name */
  | "has_scheduled_changes"
  /** column name */
  | "id"
  /** column name */
  | "notes"
  /** column name */
  | "offer_id"
  /** column name */
  | "paid_count"
  /** column name */
  | "pause_initiated_by"
  /** column name */
  | "payment_provider_id"
  /** column name */
  | "plan_id"
  /** column name */
  | "quantity"
  /** column name */
  | "remaining_count"
  /** column name */
  | "short_url"
  /** column name */
  | "source"
  /** column name */
  | "start_at"
  /** column name */
  | "status"
  /** column name */
  | "total_count"
  /** column name */
  | "type"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

export interface CustomerSubscriptionsUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<CustomerSubscriptionsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<CustomerSubscriptionsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<CustomerSubscriptionsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<CustomerSubscriptionsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<CustomerSubscriptionsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<CustomerSubscriptionsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: CustomerSubscriptionsBoolExp;
}

/** aggregate var_pop on columns */
export interface CustomerSubscriptionsVarPopFields {
  readonly auth_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly paid_count?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  readonly plan_id?: Maybe<Scalars["Float"]["output"]>;
  readonly quantity?: Maybe<Scalars["Float"]["output"]>;
  readonly remaining_count?: Maybe<Scalars["Float"]["output"]>;
  readonly total_count?: Maybe<Scalars["Float"]["output"]>;
  readonly type?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "customer_subscriptions" */
export interface CustomerSubscriptionsVarPopOrderBy {
  readonly auth_attempts?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly paid_count?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly plan_id?: InputMaybe<OrderBy>;
  readonly quantity?: InputMaybe<OrderBy>;
  readonly remaining_count?: InputMaybe<OrderBy>;
  readonly total_count?: InputMaybe<OrderBy>;
  readonly type?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface CustomerSubscriptionsVarSampFields {
  readonly auth_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly paid_count?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  readonly plan_id?: Maybe<Scalars["Float"]["output"]>;
  readonly quantity?: Maybe<Scalars["Float"]["output"]>;
  readonly remaining_count?: Maybe<Scalars["Float"]["output"]>;
  readonly total_count?: Maybe<Scalars["Float"]["output"]>;
  readonly type?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "customer_subscriptions" */
export interface CustomerSubscriptionsVarSampOrderBy {
  readonly auth_attempts?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly paid_count?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly plan_id?: InputMaybe<OrderBy>;
  readonly quantity?: InputMaybe<OrderBy>;
  readonly remaining_count?: InputMaybe<OrderBy>;
  readonly total_count?: InputMaybe<OrderBy>;
  readonly type?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface CustomerSubscriptionsVarianceFields {
  readonly auth_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly paid_count?: Maybe<Scalars["Float"]["output"]>;
  readonly payment_provider_id?: Maybe<Scalars["Float"]["output"]>;
  readonly plan_id?: Maybe<Scalars["Float"]["output"]>;
  readonly quantity?: Maybe<Scalars["Float"]["output"]>;
  readonly remaining_count?: Maybe<Scalars["Float"]["output"]>;
  readonly total_count?: Maybe<Scalars["Float"]["output"]>;
  readonly type?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "customer_subscriptions" */
export interface CustomerSubscriptionsVarianceOrderBy {
  readonly auth_attempts?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly paid_count?: InputMaybe<OrderBy>;
  readonly payment_provider_id?: InputMaybe<OrderBy>;
  readonly plan_id?: InputMaybe<OrderBy>;
  readonly quantity?: InputMaybe<OrderBy>;
  readonly remaining_count?: InputMaybe<OrderBy>;
  readonly total_count?: InputMaybe<OrderBy>;
  readonly type?: InputMaybe<OrderBy>;
}

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

/** columns and relationships of "embedding_reviews" */
export interface EmbeddingReviews {
  readonly agent_review?: Maybe<Scalars["Boolean"]["output"]>;
  readonly created_at: Scalars["timestamptz"]["output"];
  readonly human_review?: Maybe<Scalars["Boolean"]["output"]>;
  readonly id: Scalars["bigint"]["output"];
  readonly notes?: Maybe<Scalars["String"]["output"]>;
  /** An array relationship */
  readonly research_embeddings: ReadonlyArray<ResearchEmbeddings>;
  /** An aggregate relationship */
  readonly research_embeddings_aggregate: ResearchEmbeddingsAggregate;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** columns and relationships of "embedding_reviews" */
export type EmbeddingReviewsResearchEmbeddingsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResearchEmbeddingsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResearchEmbeddingsOrderBy>>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

/** columns and relationships of "embedding_reviews" */
export type EmbeddingReviewsResearchEmbeddingsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResearchEmbeddingsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResearchEmbeddingsOrderBy>>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

/** aggregated selection of "embedding_reviews" */
export interface EmbeddingReviewsAggregate {
  readonly aggregate?: Maybe<EmbeddingReviewsAggregateFields>;
  readonly nodes: ReadonlyArray<EmbeddingReviews>;
}

/** aggregate fields of "embedding_reviews" */
export interface EmbeddingReviewsAggregateFields {
  readonly avg?: Maybe<EmbeddingReviewsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<EmbeddingReviewsMaxFields>;
  readonly min?: Maybe<EmbeddingReviewsMinFields>;
  readonly stddev?: Maybe<EmbeddingReviewsStddevFields>;
  readonly stddev_pop?: Maybe<EmbeddingReviewsStddevPopFields>;
  readonly stddev_samp?: Maybe<EmbeddingReviewsStddevSampFields>;
  readonly sum?: Maybe<EmbeddingReviewsSumFields>;
  readonly var_pop?: Maybe<EmbeddingReviewsVarPopFields>;
  readonly var_samp?: Maybe<EmbeddingReviewsVarSampFields>;
  readonly variance?: Maybe<EmbeddingReviewsVarianceFields>;
}

/** aggregate fields of "embedding_reviews" */
export type EmbeddingReviewsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<EmbeddingReviewsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface EmbeddingReviewsAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "embedding_reviews". All fields are combined with a logical 'AND'. */
export interface EmbeddingReviewsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<EmbeddingReviewsBoolExp>>;
  readonly _not?: InputMaybe<EmbeddingReviewsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<EmbeddingReviewsBoolExp>>;
  readonly agent_review?: InputMaybe<BooleanComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly human_review?: InputMaybe<BooleanComparisonExp>;
  readonly id?: InputMaybe<BigintComparisonExp>;
  readonly notes?: InputMaybe<StringComparisonExp>;
  readonly research_embeddings?: InputMaybe<ResearchEmbeddingsBoolExp>;
  readonly research_embeddings_aggregate?: InputMaybe<ResearchEmbeddingsAggregateBoolExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
}

/** unique or primary key constraints on table "embedding_reviews" */
export type EmbeddingReviewsConstraint =
  /** unique or primary key constraint on columns "id" */
  "embedding_review_pkey";

/** input type for incrementing numeric columns in table "embedding_reviews" */
export interface EmbeddingReviewsIncInput {
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** input type for inserting data into table "embedding_reviews" */
export interface EmbeddingReviewsInsertInput {
  readonly agent_review?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly human_review?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly notes?: InputMaybe<Scalars["String"]["input"]>;
  readonly research_embeddings?: InputMaybe<ResearchEmbeddingsArrRelInsertInput>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate max on columns */
export interface EmbeddingReviewsMaxFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly notes?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** aggregate min on columns */
export interface EmbeddingReviewsMinFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly notes?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** response of any mutation on the table "embedding_reviews" */
export interface EmbeddingReviewsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<EmbeddingReviews>;
}

/** input type for inserting object relation for remote table "embedding_reviews" */
export interface EmbeddingReviewsObjRelInsertInput {
  readonly data: EmbeddingReviewsInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<EmbeddingReviewsOnConflict>;
}

/** on_conflict condition type for table "embedding_reviews" */
export interface EmbeddingReviewsOnConflict {
  readonly constraint: EmbeddingReviewsConstraint;
  readonly update_columns: ReadonlyArray<EmbeddingReviewsUpdateColumn>;
  readonly where?: InputMaybe<EmbeddingReviewsBoolExp>;
}

/** Ordering options when selecting data from "embedding_reviews". */
export interface EmbeddingReviewsOrderBy {
  readonly agent_review?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly human_review?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly notes?: InputMaybe<OrderBy>;
  readonly research_embeddings_aggregate?: InputMaybe<ResearchEmbeddingsAggregateOrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: embedding_reviews */
export interface EmbeddingReviewsPkColumnsInput {
  readonly id: Scalars["bigint"]["input"];
}

/** select columns of table "embedding_reviews" */
export type EmbeddingReviewsSelectColumn =
  /** column name */
  | "agent_review"
  /** column name */
  | "created_at"
  /** column name */
  | "human_review"
  /** column name */
  | "id"
  /** column name */
  | "notes"
  /** column name */
  | "updated_at";

/** input type for updating data in table "embedding_reviews" */
export interface EmbeddingReviewsSetInput {
  readonly agent_review?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly human_review?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly notes?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate stddev on columns */
export interface EmbeddingReviewsStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface EmbeddingReviewsStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface EmbeddingReviewsStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "embedding_reviews" */
export interface EmbeddingReviewsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: EmbeddingReviewsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface EmbeddingReviewsStreamCursorValueInput {
  readonly agent_review?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly human_review?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly notes?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate sum on columns */
export interface EmbeddingReviewsSumFields {
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
}

/** update columns of table "embedding_reviews" */
export type EmbeddingReviewsUpdateColumn =
  /** column name */
  | "agent_review"
  /** column name */
  | "created_at"
  /** column name */
  | "human_review"
  /** column name */
  | "id"
  /** column name */
  | "notes"
  /** column name */
  | "updated_at";

export interface EmbeddingReviewsUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<EmbeddingReviewsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<EmbeddingReviewsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: EmbeddingReviewsBoolExp;
}

/** aggregate var_pop on columns */
export interface EmbeddingReviewsVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface EmbeddingReviewsVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface EmbeddingReviewsVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "error_correlations" */
export interface ErrorCorrelations {
  readonly avg_time_difference?: Maybe<Scalars["numeric"]["output"]>;
  readonly correlation_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly source_pattern?: Maybe<Scalars["String"]["output"]>;
  readonly source_service?: Maybe<Scalars["String"]["output"]>;
  readonly target_pattern?: Maybe<Scalars["String"]["output"]>;
  readonly target_service?: Maybe<Scalars["String"]["output"]>;
}

/** aggregated selection of "error_correlations" */
export interface ErrorCorrelationsAggregate {
  readonly aggregate?: Maybe<ErrorCorrelationsAggregateFields>;
  readonly nodes: ReadonlyArray<ErrorCorrelations>;
}

/** aggregate fields of "error_correlations" */
export interface ErrorCorrelationsAggregateFields {
  readonly avg?: Maybe<ErrorCorrelationsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ErrorCorrelationsMaxFields>;
  readonly min?: Maybe<ErrorCorrelationsMinFields>;
  readonly stddev?: Maybe<ErrorCorrelationsStddevFields>;
  readonly stddev_pop?: Maybe<ErrorCorrelationsStddevPopFields>;
  readonly stddev_samp?: Maybe<ErrorCorrelationsStddevSampFields>;
  readonly sum?: Maybe<ErrorCorrelationsSumFields>;
  readonly var_pop?: Maybe<ErrorCorrelationsVarPopFields>;
  readonly var_samp?: Maybe<ErrorCorrelationsVarSampFields>;
  readonly variance?: Maybe<ErrorCorrelationsVarianceFields>;
}

/** aggregate fields of "error_correlations" */
export type ErrorCorrelationsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ErrorCorrelationsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface ErrorCorrelationsAvgFields {
  readonly avg_time_difference?: Maybe<Scalars["Float"]["output"]>;
  readonly correlation_count?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "error_correlations". All fields are combined with a logical 'AND'. */
export interface ErrorCorrelationsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ErrorCorrelationsBoolExp>>;
  readonly _not?: InputMaybe<ErrorCorrelationsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ErrorCorrelationsBoolExp>>;
  readonly avg_time_difference?: InputMaybe<NumericComparisonExp>;
  readonly correlation_count?: InputMaybe<BigintComparisonExp>;
  readonly id?: InputMaybe<BigintComparisonExp>;
  readonly source_pattern?: InputMaybe<StringComparisonExp>;
  readonly source_service?: InputMaybe<StringComparisonExp>;
  readonly target_pattern?: InputMaybe<StringComparisonExp>;
  readonly target_service?: InputMaybe<StringComparisonExp>;
}

/** aggregate max on columns */
export interface ErrorCorrelationsMaxFields {
  readonly avg_time_difference?: Maybe<Scalars["numeric"]["output"]>;
  readonly correlation_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly source_pattern?: Maybe<Scalars["String"]["output"]>;
  readonly source_service?: Maybe<Scalars["String"]["output"]>;
  readonly target_pattern?: Maybe<Scalars["String"]["output"]>;
  readonly target_service?: Maybe<Scalars["String"]["output"]>;
}

/** aggregate min on columns */
export interface ErrorCorrelationsMinFields {
  readonly avg_time_difference?: Maybe<Scalars["numeric"]["output"]>;
  readonly correlation_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly source_pattern?: Maybe<Scalars["String"]["output"]>;
  readonly source_service?: Maybe<Scalars["String"]["output"]>;
  readonly target_pattern?: Maybe<Scalars["String"]["output"]>;
  readonly target_service?: Maybe<Scalars["String"]["output"]>;
}

/** Ordering options when selecting data from "error_correlations". */
export interface ErrorCorrelationsOrderBy {
  readonly avg_time_difference?: InputMaybe<OrderBy>;
  readonly correlation_count?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly source_pattern?: InputMaybe<OrderBy>;
  readonly source_service?: InputMaybe<OrderBy>;
  readonly target_pattern?: InputMaybe<OrderBy>;
  readonly target_service?: InputMaybe<OrderBy>;
}

/** select columns of table "error_correlations" */
export type ErrorCorrelationsSelectColumn =
  /** column name */
  | "avg_time_difference"
  /** column name */
  | "correlation_count"
  /** column name */
  | "id"
  /** column name */
  | "source_pattern"
  /** column name */
  | "source_service"
  /** column name */
  | "target_pattern"
  /** column name */
  | "target_service";

/** aggregate stddev on columns */
export interface ErrorCorrelationsStddevFields {
  readonly avg_time_difference?: Maybe<Scalars["Float"]["output"]>;
  readonly correlation_count?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface ErrorCorrelationsStddevPopFields {
  readonly avg_time_difference?: Maybe<Scalars["Float"]["output"]>;
  readonly correlation_count?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface ErrorCorrelationsStddevSampFields {
  readonly avg_time_difference?: Maybe<Scalars["Float"]["output"]>;
  readonly correlation_count?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "error_correlations" */
export interface ErrorCorrelationsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ErrorCorrelationsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ErrorCorrelationsStreamCursorValueInput {
  readonly avg_time_difference?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly correlation_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly source_pattern?: InputMaybe<Scalars["String"]["input"]>;
  readonly source_service?: InputMaybe<Scalars["String"]["input"]>;
  readonly target_pattern?: InputMaybe<Scalars["String"]["input"]>;
  readonly target_service?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface ErrorCorrelationsSumFields {
  readonly avg_time_difference?: Maybe<Scalars["numeric"]["output"]>;
  readonly correlation_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate var_pop on columns */
export interface ErrorCorrelationsVarPopFields {
  readonly avg_time_difference?: Maybe<Scalars["Float"]["output"]>;
  readonly correlation_count?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface ErrorCorrelationsVarSampFields {
  readonly avg_time_difference?: Maybe<Scalars["Float"]["output"]>;
  readonly correlation_count?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface ErrorCorrelationsVarianceFields {
  readonly avg_time_difference?: Maybe<Scalars["Float"]["output"]>;
  readonly correlation_count?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "error_frequency" */
export interface ErrorFrequency {
  readonly error_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly error_type?: Maybe<Scalars["error_type"]["output"]>;
  readonly service_name?: Maybe<Scalars["String"]["output"]>;
  readonly severity?: Maybe<Scalars["error_severity"]["output"]>;
  readonly time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** aggregated selection of "error_frequency" */
export interface ErrorFrequencyAggregate {
  readonly aggregate?: Maybe<ErrorFrequencyAggregateFields>;
  readonly nodes: ReadonlyArray<ErrorFrequency>;
}

/** aggregate fields of "error_frequency" */
export interface ErrorFrequencyAggregateFields {
  readonly avg?: Maybe<ErrorFrequencyAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ErrorFrequencyMaxFields>;
  readonly min?: Maybe<ErrorFrequencyMinFields>;
  readonly stddev?: Maybe<ErrorFrequencyStddevFields>;
  readonly stddev_pop?: Maybe<ErrorFrequencyStddevPopFields>;
  readonly stddev_samp?: Maybe<ErrorFrequencyStddevSampFields>;
  readonly sum?: Maybe<ErrorFrequencySumFields>;
  readonly var_pop?: Maybe<ErrorFrequencyVarPopFields>;
  readonly var_samp?: Maybe<ErrorFrequencyVarSampFields>;
  readonly variance?: Maybe<ErrorFrequencyVarianceFields>;
}

/** aggregate fields of "error_frequency" */
export type ErrorFrequencyAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ErrorFrequencySelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface ErrorFrequencyAvgFields {
  readonly 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 interface ErrorFrequencyBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ErrorFrequencyBoolExp>>;
  readonly _not?: InputMaybe<ErrorFrequencyBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ErrorFrequencyBoolExp>>;
  readonly error_count?: InputMaybe<BigintComparisonExp>;
  readonly error_type?: InputMaybe<ErrorTypeComparisonExp>;
  readonly service_name?: InputMaybe<StringComparisonExp>;
  readonly severity?: InputMaybe<ErrorSeverityComparisonExp>;
  readonly time_bucket?: InputMaybe<TimestamptzComparisonExp>;
}

/** aggregate max on columns */
export interface ErrorFrequencyMaxFields {
  readonly error_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly error_type?: Maybe<Scalars["error_type"]["output"]>;
  readonly service_name?: Maybe<Scalars["String"]["output"]>;
  readonly severity?: Maybe<Scalars["error_severity"]["output"]>;
  readonly time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** aggregate min on columns */
export interface ErrorFrequencyMinFields {
  readonly error_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly error_type?: Maybe<Scalars["error_type"]["output"]>;
  readonly service_name?: Maybe<Scalars["String"]["output"]>;
  readonly severity?: Maybe<Scalars["error_severity"]["output"]>;
  readonly time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** Ordering options when selecting data from "error_frequency". */
export interface ErrorFrequencyOrderBy {
  readonly error_count?: InputMaybe<OrderBy>;
  readonly error_type?: InputMaybe<OrderBy>;
  readonly service_name?: InputMaybe<OrderBy>;
  readonly severity?: InputMaybe<OrderBy>;
  readonly time_bucket?: InputMaybe<OrderBy>;
}

/** select columns of table "error_frequency" */
export type ErrorFrequencySelectColumn =
  /** column name */
  | "error_count"
  /** column name */
  | "error_type"
  /** column name */
  | "service_name"
  /** column name */
  | "severity"
  /** column name */
  | "time_bucket";

/** aggregate stddev on columns */
export interface ErrorFrequencyStddevFields {
  readonly error_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface ErrorFrequencyStddevPopFields {
  readonly error_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface ErrorFrequencyStddevSampFields {
  readonly error_count?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "error_frequency" */
export interface ErrorFrequencyStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ErrorFrequencyStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ErrorFrequencyStreamCursorValueInput {
  readonly error_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  readonly service_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly severity?: InputMaybe<Scalars["error_severity"]["input"]>;
  readonly time_bucket?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate sum on columns */
export interface ErrorFrequencySumFields {
  readonly error_count?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate var_pop on columns */
export interface ErrorFrequencyVarPopFields {
  readonly error_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface ErrorFrequencyVarSampFields {
  readonly error_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface ErrorFrequencyVarianceFields {
  readonly error_count?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "error_logs" */
export interface ErrorLogs {
  readonly context?: Maybe<Scalars["jsonb"]["output"]>;
  readonly correlation_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly domain?: Maybe<Scalars["String"]["output"]>;
  readonly environment: Scalars["String"]["output"];
  readonly error_hash?: Maybe<Scalars["String"]["output"]>;
  readonly error_pattern?: Maybe<Scalars["String"]["output"]>;
  readonly error_type: Scalars["error_type"]["output"];
  readonly frequency_data?: Maybe<Scalars["jsonb"]["output"]>;
  readonly github_repo?: Maybe<Scalars["String"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  readonly is_new_pattern?: Maybe<Scalars["Boolean"]["output"]>;
  readonly message: Scalars["String"]["output"];
  readonly metadata?: Maybe<Scalars["jsonb"]["output"]>;
  readonly related_errors?: Maybe<Scalars["jsonb"]["output"]>;
  readonly request_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly service_name: Scalars["String"]["output"];
  readonly severity: Scalars["error_severity"]["output"];
  readonly stack_trace?: Maybe<Scalars["String"]["output"]>;
  readonly 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 interface ErrorLogsAggregate {
  readonly aggregate?: Maybe<ErrorLogsAggregateFields>;
  readonly nodes: ReadonlyArray<ErrorLogs>;
}

/** aggregate fields of "error_logs" */
export interface ErrorLogsAggregateFields {
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ErrorLogsMaxFields>;
  readonly min?: Maybe<ErrorLogsMinFields>;
}

/** aggregate fields of "error_logs" */
export type ErrorLogsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ErrorLogsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export interface ErrorLogsAppendInput {
  readonly context?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly frequency_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly 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 interface ErrorLogsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ErrorLogsBoolExp>>;
  readonly _not?: InputMaybe<ErrorLogsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ErrorLogsBoolExp>>;
  readonly context?: InputMaybe<JsonbComparisonExp>;
  readonly correlation_id?: InputMaybe<UuidComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly domain?: InputMaybe<StringComparisonExp>;
  readonly environment?: InputMaybe<StringComparisonExp>;
  readonly error_hash?: InputMaybe<StringComparisonExp>;
  readonly error_pattern?: InputMaybe<StringComparisonExp>;
  readonly error_type?: InputMaybe<ErrorTypeComparisonExp>;
  readonly frequency_data?: InputMaybe<JsonbComparisonExp>;
  readonly github_repo?: InputMaybe<StringComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly is_new_pattern?: InputMaybe<BooleanComparisonExp>;
  readonly message?: InputMaybe<StringComparisonExp>;
  readonly metadata?: InputMaybe<JsonbComparisonExp>;
  readonly related_errors?: InputMaybe<JsonbComparisonExp>;
  readonly request_id?: InputMaybe<UuidComparisonExp>;
  readonly service_name?: InputMaybe<StringComparisonExp>;
  readonly severity?: InputMaybe<ErrorSeverityComparisonExp>;
  readonly stack_trace?: InputMaybe<StringComparisonExp>;
  readonly user_id?: InputMaybe<UuidComparisonExp>;
}

/** unique or primary key constraints on table "error_logs" */
export type ErrorLogsConstraint =
  /** unique or primary key constraint on columns "id" */
  "error_logs_pkey";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface ErrorLogsDeleteAtPathInput {
  readonly context?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
  readonly frequency_data?: InputMaybe<
    ReadonlyArray<Scalars["String"]["input"]>
  >;
  readonly metadata?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
  readonly related_errors?: InputMaybe<
    ReadonlyArray<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 interface ErrorLogsDeleteElemInput {
  readonly context?: InputMaybe<Scalars["Int"]["input"]>;
  readonly frequency_data?: InputMaybe<Scalars["Int"]["input"]>;
  readonly metadata?: InputMaybe<Scalars["Int"]["input"]>;
  readonly related_errors?: InputMaybe<Scalars["Int"]["input"]>;
}

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export interface ErrorLogsDeleteKeyInput {
  readonly context?: InputMaybe<Scalars["String"]["input"]>;
  readonly frequency_data?: InputMaybe<Scalars["String"]["input"]>;
  readonly metadata?: InputMaybe<Scalars["String"]["input"]>;
  readonly related_errors?: InputMaybe<Scalars["String"]["input"]>;
}

/** input type for inserting data into table "error_logs" */
export interface ErrorLogsInsertInput {
  readonly context?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly correlation_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly domain?: InputMaybe<Scalars["String"]["input"]>;
  readonly environment?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_hash?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_pattern?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  readonly frequency_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly github_repo?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly is_new_pattern?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly message?: InputMaybe<Scalars["String"]["input"]>;
  readonly metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly related_errors?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly request_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly service_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly severity?: InputMaybe<Scalars["error_severity"]["input"]>;
  readonly stack_trace?: InputMaybe<Scalars["String"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** aggregate max on columns */
export interface ErrorLogsMaxFields {
  readonly correlation_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly domain?: Maybe<Scalars["String"]["output"]>;
  readonly environment?: Maybe<Scalars["String"]["output"]>;
  readonly error_hash?: Maybe<Scalars["String"]["output"]>;
  readonly error_pattern?: Maybe<Scalars["String"]["output"]>;
  readonly error_type?: Maybe<Scalars["error_type"]["output"]>;
  readonly github_repo?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly message?: Maybe<Scalars["String"]["output"]>;
  readonly request_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly service_name?: Maybe<Scalars["String"]["output"]>;
  readonly severity?: Maybe<Scalars["error_severity"]["output"]>;
  readonly stack_trace?: Maybe<Scalars["String"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** aggregate min on columns */
export interface ErrorLogsMinFields {
  readonly correlation_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly domain?: Maybe<Scalars["String"]["output"]>;
  readonly environment?: Maybe<Scalars["String"]["output"]>;
  readonly error_hash?: Maybe<Scalars["String"]["output"]>;
  readonly error_pattern?: Maybe<Scalars["String"]["output"]>;
  readonly error_type?: Maybe<Scalars["error_type"]["output"]>;
  readonly github_repo?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly message?: Maybe<Scalars["String"]["output"]>;
  readonly request_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly service_name?: Maybe<Scalars["String"]["output"]>;
  readonly severity?: Maybe<Scalars["error_severity"]["output"]>;
  readonly stack_trace?: Maybe<Scalars["String"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** response of any mutation on the table "error_logs" */
export interface ErrorLogsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<ErrorLogs>;
}

/** on_conflict condition type for table "error_logs" */
export interface ErrorLogsOnConflict {
  readonly constraint: ErrorLogsConstraint;
  readonly update_columns: ReadonlyArray<ErrorLogsUpdateColumn>;
  readonly where?: InputMaybe<ErrorLogsBoolExp>;
}

/** Ordering options when selecting data from "error_logs". */
export interface ErrorLogsOrderBy {
  readonly context?: InputMaybe<OrderBy>;
  readonly correlation_id?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly domain?: InputMaybe<OrderBy>;
  readonly environment?: InputMaybe<OrderBy>;
  readonly error_hash?: InputMaybe<OrderBy>;
  readonly error_pattern?: InputMaybe<OrderBy>;
  readonly error_type?: InputMaybe<OrderBy>;
  readonly frequency_data?: InputMaybe<OrderBy>;
  readonly github_repo?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly is_new_pattern?: InputMaybe<OrderBy>;
  readonly message?: InputMaybe<OrderBy>;
  readonly metadata?: InputMaybe<OrderBy>;
  readonly related_errors?: InputMaybe<OrderBy>;
  readonly request_id?: InputMaybe<OrderBy>;
  readonly service_name?: InputMaybe<OrderBy>;
  readonly severity?: InputMaybe<OrderBy>;
  readonly stack_trace?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: error_logs */
export interface ErrorLogsPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** prepend existing jsonb value of filtered columns with new jsonb value */
export interface ErrorLogsPrependInput {
  readonly context?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly frequency_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly related_errors?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** select columns of table "error_logs" */
export type ErrorLogsSelectColumn =
  /** column name */
  | "context"
  /** column name */
  | "correlation_id"
  /** column name */
  | "created_at"
  /** column name */
  | "domain"
  /** column name */
  | "environment"
  /** column name */
  | "error_hash"
  /** column name */
  | "error_pattern"
  /** column name */
  | "error_type"
  /** column name */
  | "frequency_data"
  /** column name */
  | "github_repo"
  /** column name */
  | "id"
  /** column name */
  | "is_new_pattern"
  /** column name */
  | "message"
  /** column name */
  | "metadata"
  /** column name */
  | "related_errors"
  /** column name */
  | "request_id"
  /** column name */
  | "service_name"
  /** column name */
  | "severity"
  /** column name */
  | "stack_trace"
  /** column name */
  | "user_id";

/** input type for updating data in table "error_logs" */
export interface ErrorLogsSetInput {
  readonly context?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly correlation_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly domain?: InputMaybe<Scalars["String"]["input"]>;
  readonly environment?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_hash?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_pattern?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  readonly frequency_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly github_repo?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly is_new_pattern?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly message?: InputMaybe<Scalars["String"]["input"]>;
  readonly metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly related_errors?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly request_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly service_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly severity?: InputMaybe<Scalars["error_severity"]["input"]>;
  readonly stack_trace?: InputMaybe<Scalars["String"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** Streaming cursor of the table "error_logs" */
export interface ErrorLogsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ErrorLogsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ErrorLogsStreamCursorValueInput {
  readonly context?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly correlation_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly domain?: InputMaybe<Scalars["String"]["input"]>;
  readonly environment?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_hash?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_pattern?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  readonly frequency_data?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly github_repo?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly is_new_pattern?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly message?: InputMaybe<Scalars["String"]["input"]>;
  readonly metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly related_errors?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly request_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly service_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly severity?: InputMaybe<Scalars["error_severity"]["input"]>;
  readonly stack_trace?: InputMaybe<Scalars["String"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** update columns of table "error_logs" */
export type ErrorLogsUpdateColumn =
  /** column name */
  | "context"
  /** column name */
  | "correlation_id"
  /** column name */
  | "created_at"
  /** column name */
  | "domain"
  /** column name */
  | "environment"
  /** column name */
  | "error_hash"
  /** column name */
  | "error_pattern"
  /** column name */
  | "error_type"
  /** column name */
  | "frequency_data"
  /** column name */
  | "github_repo"
  /** column name */
  | "id"
  /** column name */
  | "is_new_pattern"
  /** column name */
  | "message"
  /** column name */
  | "metadata"
  /** column name */
  | "related_errors"
  /** column name */
  | "request_id"
  /** column name */
  | "service_name"
  /** column name */
  | "severity"
  /** column name */
  | "stack_trace"
  /** column name */
  | "user_id";

export interface ErrorLogsUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<ErrorLogsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<ErrorLogsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<ErrorLogsDeleteKeyInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<ErrorLogsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<ErrorLogsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: ErrorLogsBoolExp;
}

/** columns and relationships of "error_metrics" */
export interface ErrorMetrics {
  readonly error_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly error_type?: Maybe<Scalars["error_type"]["output"]>;
  readonly service_name?: Maybe<Scalars["String"]["output"]>;
  readonly severity?: Maybe<Scalars["error_severity"]["output"]>;
  readonly time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** aggregated selection of "error_metrics" */
export interface ErrorMetricsAggregate {
  readonly aggregate?: Maybe<ErrorMetricsAggregateFields>;
  readonly nodes: ReadonlyArray<ErrorMetrics>;
}

/** aggregate fields of "error_metrics" */
export interface ErrorMetricsAggregateFields {
  readonly avg?: Maybe<ErrorMetricsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ErrorMetricsMaxFields>;
  readonly min?: Maybe<ErrorMetricsMinFields>;
  readonly stddev?: Maybe<ErrorMetricsStddevFields>;
  readonly stddev_pop?: Maybe<ErrorMetricsStddevPopFields>;
  readonly stddev_samp?: Maybe<ErrorMetricsStddevSampFields>;
  readonly sum?: Maybe<ErrorMetricsSumFields>;
  readonly var_pop?: Maybe<ErrorMetricsVarPopFields>;
  readonly var_samp?: Maybe<ErrorMetricsVarSampFields>;
  readonly variance?: Maybe<ErrorMetricsVarianceFields>;
}

/** aggregate fields of "error_metrics" */
export type ErrorMetricsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ErrorMetricsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface ErrorMetricsAvgFields {
  readonly 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 interface ErrorMetricsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ErrorMetricsBoolExp>>;
  readonly _not?: InputMaybe<ErrorMetricsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ErrorMetricsBoolExp>>;
  readonly error_count?: InputMaybe<BigintComparisonExp>;
  readonly error_type?: InputMaybe<ErrorTypeComparisonExp>;
  readonly service_name?: InputMaybe<StringComparisonExp>;
  readonly severity?: InputMaybe<ErrorSeverityComparisonExp>;
  readonly time_bucket?: InputMaybe<TimestamptzComparisonExp>;
}

/** aggregate max on columns */
export interface ErrorMetricsMaxFields {
  readonly error_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly error_type?: Maybe<Scalars["error_type"]["output"]>;
  readonly service_name?: Maybe<Scalars["String"]["output"]>;
  readonly severity?: Maybe<Scalars["error_severity"]["output"]>;
  readonly time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** aggregate min on columns */
export interface ErrorMetricsMinFields {
  readonly error_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly error_type?: Maybe<Scalars["error_type"]["output"]>;
  readonly service_name?: Maybe<Scalars["String"]["output"]>;
  readonly severity?: Maybe<Scalars["error_severity"]["output"]>;
  readonly time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** Ordering options when selecting data from "error_metrics". */
export interface ErrorMetricsOrderBy {
  readonly error_count?: InputMaybe<OrderBy>;
  readonly error_type?: InputMaybe<OrderBy>;
  readonly service_name?: InputMaybe<OrderBy>;
  readonly severity?: InputMaybe<OrderBy>;
  readonly time_bucket?: InputMaybe<OrderBy>;
}

/** select columns of table "error_metrics" */
export type ErrorMetricsSelectColumn =
  /** column name */
  | "error_count"
  /** column name */
  | "error_type"
  /** column name */
  | "service_name"
  /** column name */
  | "severity"
  /** column name */
  | "time_bucket";

/** aggregate stddev on columns */
export interface ErrorMetricsStddevFields {
  readonly error_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface ErrorMetricsStddevPopFields {
  readonly error_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface ErrorMetricsStddevSampFields {
  readonly error_count?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "error_metrics" */
export interface ErrorMetricsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ErrorMetricsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ErrorMetricsStreamCursorValueInput {
  readonly error_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  readonly service_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly severity?: InputMaybe<Scalars["error_severity"]["input"]>;
  readonly time_bucket?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate sum on columns */
export interface ErrorMetricsSumFields {
  readonly error_count?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate var_pop on columns */
export interface ErrorMetricsVarPopFields {
  readonly error_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface ErrorMetricsVarSampFields {
  readonly error_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface ErrorMetricsVarianceFields {
  readonly error_count?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "error_patterns" */
export interface ErrorPatterns {
  readonly contexts?: Maybe<Scalars["jsonb"]["output"]>;
  readonly daily_frequency?: Maybe<Scalars["float8"]["output"]>;
  readonly days_active?: Maybe<Scalars["bigint"]["output"]>;
  readonly error_hash?: Maybe<Scalars["String"]["output"]>;
  readonly error_pattern?: Maybe<Scalars["String"]["output"]>;
  readonly first_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly is_new?: Maybe<Scalars["Boolean"]["output"]>;
  readonly last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly service_name?: Maybe<Scalars["String"]["output"]>;
  readonly severity_levels?: Maybe<
    ReadonlyArray<Scalars["error_severity"]["output"]>
  >;
}

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

/** aggregated selection of "error_patterns" */
export interface ErrorPatternsAggregate {
  readonly aggregate?: Maybe<ErrorPatternsAggregateFields>;
  readonly nodes: ReadonlyArray<ErrorPatterns>;
}

/** aggregate fields of "error_patterns" */
export interface ErrorPatternsAggregateFields {
  readonly avg?: Maybe<ErrorPatternsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ErrorPatternsMaxFields>;
  readonly min?: Maybe<ErrorPatternsMinFields>;
  readonly stddev?: Maybe<ErrorPatternsStddevFields>;
  readonly stddev_pop?: Maybe<ErrorPatternsStddevPopFields>;
  readonly stddev_samp?: Maybe<ErrorPatternsStddevSampFields>;
  readonly sum?: Maybe<ErrorPatternsSumFields>;
  readonly var_pop?: Maybe<ErrorPatternsVarPopFields>;
  readonly var_samp?: Maybe<ErrorPatternsVarSampFields>;
  readonly variance?: Maybe<ErrorPatternsVarianceFields>;
}

/** aggregate fields of "error_patterns" */
export type ErrorPatternsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ErrorPatternsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface ErrorPatternsAvgFields {
  readonly daily_frequency?: Maybe<Scalars["Float"]["output"]>;
  readonly days_active?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly 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 interface ErrorPatternsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ErrorPatternsBoolExp>>;
  readonly _not?: InputMaybe<ErrorPatternsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ErrorPatternsBoolExp>>;
  readonly contexts?: InputMaybe<JsonbComparisonExp>;
  readonly daily_frequency?: InputMaybe<Float8ComparisonExp>;
  readonly days_active?: InputMaybe<BigintComparisonExp>;
  readonly error_hash?: InputMaybe<StringComparisonExp>;
  readonly error_pattern?: InputMaybe<StringComparisonExp>;
  readonly first_seen?: InputMaybe<TimestamptzComparisonExp>;
  readonly id?: InputMaybe<BigintComparisonExp>;
  readonly is_new?: InputMaybe<BooleanComparisonExp>;
  readonly last_seen?: InputMaybe<TimestamptzComparisonExp>;
  readonly occurrence_count?: InputMaybe<BigintComparisonExp>;
  readonly service_name?: InputMaybe<StringComparisonExp>;
  readonly severity_levels?: InputMaybe<ErrorSeverityArrayComparisonExp>;
}

/** aggregate max on columns */
export interface ErrorPatternsMaxFields {
  readonly daily_frequency?: Maybe<Scalars["float8"]["output"]>;
  readonly days_active?: Maybe<Scalars["bigint"]["output"]>;
  readonly error_hash?: Maybe<Scalars["String"]["output"]>;
  readonly error_pattern?: Maybe<Scalars["String"]["output"]>;
  readonly first_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly service_name?: Maybe<Scalars["String"]["output"]>;
  readonly severity_levels?: Maybe<
    ReadonlyArray<Scalars["error_severity"]["output"]>
  >;
}

/** aggregate min on columns */
export interface ErrorPatternsMinFields {
  readonly daily_frequency?: Maybe<Scalars["float8"]["output"]>;
  readonly days_active?: Maybe<Scalars["bigint"]["output"]>;
  readonly error_hash?: Maybe<Scalars["String"]["output"]>;
  readonly error_pattern?: Maybe<Scalars["String"]["output"]>;
  readonly first_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly service_name?: Maybe<Scalars["String"]["output"]>;
  readonly severity_levels?: Maybe<
    ReadonlyArray<Scalars["error_severity"]["output"]>
  >;
}

/** Ordering options when selecting data from "error_patterns". */
export interface ErrorPatternsOrderBy {
  readonly contexts?: InputMaybe<OrderBy>;
  readonly daily_frequency?: InputMaybe<OrderBy>;
  readonly days_active?: InputMaybe<OrderBy>;
  readonly error_hash?: InputMaybe<OrderBy>;
  readonly error_pattern?: InputMaybe<OrderBy>;
  readonly first_seen?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly is_new?: InputMaybe<OrderBy>;
  readonly last_seen?: InputMaybe<OrderBy>;
  readonly occurrence_count?: InputMaybe<OrderBy>;
  readonly service_name?: InputMaybe<OrderBy>;
  readonly severity_levels?: InputMaybe<OrderBy>;
}

/** select columns of table "error_patterns" */
export type ErrorPatternsSelectColumn =
  /** column name */
  | "contexts"
  /** column name */
  | "daily_frequency"
  /** column name */
  | "days_active"
  /** column name */
  | "error_hash"
  /** column name */
  | "error_pattern"
  /** column name */
  | "first_seen"
  /** column name */
  | "id"
  /** column name */
  | "is_new"
  /** column name */
  | "last_seen"
  /** column name */
  | "occurrence_count"
  /** column name */
  | "service_name"
  /** column name */
  | "severity_levels";

/** aggregate stddev on columns */
export interface ErrorPatternsStddevFields {
  readonly daily_frequency?: Maybe<Scalars["Float"]["output"]>;
  readonly days_active?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface ErrorPatternsStddevPopFields {
  readonly daily_frequency?: Maybe<Scalars["Float"]["output"]>;
  readonly days_active?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface ErrorPatternsStddevSampFields {
  readonly daily_frequency?: Maybe<Scalars["Float"]["output"]>;
  readonly days_active?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "error_patterns" */
export interface ErrorPatternsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ErrorPatternsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ErrorPatternsStreamCursorValueInput {
  readonly contexts?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly daily_frequency?: InputMaybe<Scalars["float8"]["input"]>;
  readonly days_active?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly error_hash?: InputMaybe<Scalars["String"]["input"]>;
  readonly error_pattern?: InputMaybe<Scalars["String"]["input"]>;
  readonly first_seen?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly is_new?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly last_seen?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly occurrence_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly service_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly severity_levels?: InputMaybe<
    ReadonlyArray<Scalars["error_severity"]["input"]>
  >;
}

/** aggregate sum on columns */
export interface ErrorPatternsSumFields {
  readonly daily_frequency?: Maybe<Scalars["float8"]["output"]>;
  readonly days_active?: Maybe<Scalars["bigint"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate var_pop on columns */
export interface ErrorPatternsVarPopFields {
  readonly daily_frequency?: Maybe<Scalars["Float"]["output"]>;
  readonly days_active?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface ErrorPatternsVarSampFields {
  readonly daily_frequency?: Maybe<Scalars["Float"]["output"]>;
  readonly days_active?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface ErrorPatternsVarianceFields {
  readonly daily_frequency?: Maybe<Scalars["Float"]["output"]>;
  readonly days_active?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["Float"]["output"]>;
}

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

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

/** columns and relationships of "error_stats" */
export interface ErrorStats {
  readonly calls?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly mean_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly query?: Maybe<Scalars["String"]["output"]>;
  readonly queryid?: Maybe<Scalars["bigint"]["output"]>;
  readonly rows?: Maybe<Scalars["bigint"]["output"]>;
  readonly toplevel?: Maybe<Scalars["Boolean"]["output"]>;
}

/** aggregated selection of "error_stats" */
export interface ErrorStatsAggregate {
  readonly aggregate?: Maybe<ErrorStatsAggregateFields>;
  readonly nodes: ReadonlyArray<ErrorStats>;
}

/** aggregate fields of "error_stats" */
export interface ErrorStatsAggregateFields {
  readonly avg?: Maybe<ErrorStatsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ErrorStatsMaxFields>;
  readonly min?: Maybe<ErrorStatsMinFields>;
  readonly stddev?: Maybe<ErrorStatsStddevFields>;
  readonly stddev_pop?: Maybe<ErrorStatsStddevPopFields>;
  readonly stddev_samp?: Maybe<ErrorStatsStddevSampFields>;
  readonly sum?: Maybe<ErrorStatsSumFields>;
  readonly var_pop?: Maybe<ErrorStatsVarPopFields>;
  readonly var_samp?: Maybe<ErrorStatsVarSampFields>;
  readonly variance?: Maybe<ErrorStatsVarianceFields>;
}

/** aggregate fields of "error_stats" */
export type ErrorStatsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ErrorStatsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface ErrorStatsAvgFields {
  readonly calls?: Maybe<Scalars["Float"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly mean_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly queryid?: Maybe<Scalars["Float"]["output"]>;
  readonly rows?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "error_stats". All fields are combined with a logical 'AND'. */
export interface ErrorStatsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ErrorStatsBoolExp>>;
  readonly _not?: InputMaybe<ErrorStatsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ErrorStatsBoolExp>>;
  readonly calls?: InputMaybe<BigintComparisonExp>;
  readonly max_exec_time?: InputMaybe<Float8ComparisonExp>;
  readonly mean_exec_time?: InputMaybe<Float8ComparisonExp>;
  readonly query?: InputMaybe<StringComparisonExp>;
  readonly queryid?: InputMaybe<BigintComparisonExp>;
  readonly rows?: InputMaybe<BigintComparisonExp>;
  readonly toplevel?: InputMaybe<BooleanComparisonExp>;
}

/** aggregate max on columns */
export interface ErrorStatsMaxFields {
  readonly calls?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly mean_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly query?: Maybe<Scalars["String"]["output"]>;
  readonly queryid?: Maybe<Scalars["bigint"]["output"]>;
  readonly rows?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate min on columns */
export interface ErrorStatsMinFields {
  readonly calls?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly mean_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly query?: Maybe<Scalars["String"]["output"]>;
  readonly queryid?: Maybe<Scalars["bigint"]["output"]>;
  readonly rows?: Maybe<Scalars["bigint"]["output"]>;
}

/** Ordering options when selecting data from "error_stats". */
export interface ErrorStatsOrderBy {
  readonly calls?: InputMaybe<OrderBy>;
  readonly max_exec_time?: InputMaybe<OrderBy>;
  readonly mean_exec_time?: InputMaybe<OrderBy>;
  readonly query?: InputMaybe<OrderBy>;
  readonly queryid?: InputMaybe<OrderBy>;
  readonly rows?: InputMaybe<OrderBy>;
  readonly toplevel?: InputMaybe<OrderBy>;
}

/** select columns of table "error_stats" */
export type ErrorStatsSelectColumn =
  /** column name */
  | "calls"
  /** column name */
  | "max_exec_time"
  /** column name */
  | "mean_exec_time"
  /** column name */
  | "query"
  /** column name */
  | "queryid"
  /** column name */
  | "rows"
  /** column name */
  | "toplevel";

/** aggregate stddev on columns */
export interface ErrorStatsStddevFields {
  readonly calls?: Maybe<Scalars["Float"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly mean_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly queryid?: Maybe<Scalars["Float"]["output"]>;
  readonly rows?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface ErrorStatsStddevPopFields {
  readonly calls?: Maybe<Scalars["Float"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly mean_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly queryid?: Maybe<Scalars["Float"]["output"]>;
  readonly rows?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface ErrorStatsStddevSampFields {
  readonly calls?: Maybe<Scalars["Float"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly mean_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly queryid?: Maybe<Scalars["Float"]["output"]>;
  readonly rows?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "error_stats" */
export interface ErrorStatsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ErrorStatsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ErrorStatsStreamCursorValueInput {
  readonly calls?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly max_exec_time?: InputMaybe<Scalars["float8"]["input"]>;
  readonly mean_exec_time?: InputMaybe<Scalars["float8"]["input"]>;
  readonly query?: InputMaybe<Scalars["String"]["input"]>;
  readonly queryid?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly rows?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly toplevel?: InputMaybe<Scalars["Boolean"]["input"]>;
}

/** aggregate sum on columns */
export interface ErrorStatsSumFields {
  readonly calls?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly mean_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly queryid?: Maybe<Scalars["bigint"]["output"]>;
  readonly rows?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate var_pop on columns */
export interface ErrorStatsVarPopFields {
  readonly calls?: Maybe<Scalars["Float"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly mean_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly queryid?: Maybe<Scalars["Float"]["output"]>;
  readonly rows?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface ErrorStatsVarSampFields {
  readonly calls?: Maybe<Scalars["Float"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly mean_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly queryid?: Maybe<Scalars["Float"]["output"]>;
  readonly rows?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface ErrorStatsVarianceFields {
  readonly calls?: Maybe<Scalars["Float"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly mean_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly queryid?: Maybe<Scalars["Float"]["output"]>;
  readonly rows?: Maybe<Scalars["Float"]["output"]>;
}

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

/** columns and relationships of "feature_requests" */
export interface FeatureRequests {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly downvotes?: Maybe<Scalars["Int"]["output"]>;
  readonly engagement_score?: Maybe<Scalars["Int"]["output"]>;
  /** An array relationship */
  readonly feature_votes: ReadonlyArray<FeatureVotes>;
  /** An aggregate relationship */
  readonly feature_votes_aggregate: FeatureVotesAggregate;
  readonly id: Scalars["uuid"]["output"];
  readonly priority_score?: Maybe<Scalars["Int"]["output"]>;
  readonly status: Scalars["String"]["output"];
  readonly title: Scalars["String"]["output"];
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Int"]["output"]>;
}

/** columns and relationships of "feature_requests" */
export type FeatureRequestsFeatureVotesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeatureVotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeatureVotesOrderBy>>;
  where?: InputMaybe<FeatureVotesBoolExp>;
};

/** columns and relationships of "feature_requests" */
export type FeatureRequestsFeatureVotesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeatureVotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeatureVotesOrderBy>>;
  where?: InputMaybe<FeatureVotesBoolExp>;
};

/** aggregated selection of "feature_requests" */
export interface FeatureRequestsAggregate {
  readonly aggregate?: Maybe<FeatureRequestsAggregateFields>;
  readonly nodes: ReadonlyArray<FeatureRequests>;
}

/** aggregate fields of "feature_requests" */
export interface FeatureRequestsAggregateFields {
  readonly avg?: Maybe<FeatureRequestsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<FeatureRequestsMaxFields>;
  readonly min?: Maybe<FeatureRequestsMinFields>;
  readonly stddev?: Maybe<FeatureRequestsStddevFields>;
  readonly stddev_pop?: Maybe<FeatureRequestsStddevPopFields>;
  readonly stddev_samp?: Maybe<FeatureRequestsStddevSampFields>;
  readonly sum?: Maybe<FeatureRequestsSumFields>;
  readonly var_pop?: Maybe<FeatureRequestsVarPopFields>;
  readonly var_samp?: Maybe<FeatureRequestsVarSampFields>;
  readonly variance?: Maybe<FeatureRequestsVarianceFields>;
}

/** aggregate fields of "feature_requests" */
export type FeatureRequestsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<FeatureRequestsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface FeatureRequestsAvgFields {
  readonly downvotes?: Maybe<Scalars["Float"]["output"]>;
  readonly engagement_score?: Maybe<Scalars["Float"]["output"]>;
  readonly priority_score?: Maybe<Scalars["Float"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "feature_requests". All fields are combined with a logical 'AND'. */
export interface FeatureRequestsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<FeatureRequestsBoolExp>>;
  readonly _not?: InputMaybe<FeatureRequestsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<FeatureRequestsBoolExp>>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly description?: InputMaybe<StringComparisonExp>;
  readonly downvotes?: InputMaybe<IntComparisonExp>;
  readonly engagement_score?: InputMaybe<IntComparisonExp>;
  readonly feature_votes?: InputMaybe<FeatureVotesBoolExp>;
  readonly feature_votes_aggregate?: InputMaybe<FeatureVotesAggregateBoolExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly priority_score?: InputMaybe<IntComparisonExp>;
  readonly status?: InputMaybe<StringComparisonExp>;
  readonly title?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly upvotes?: InputMaybe<IntComparisonExp>;
}

/** unique or primary key constraints on table "feature_requests" */
export type FeatureRequestsConstraint =
  /** unique or primary key constraint on columns "id" */
  "feature_requests_pkey";

/** input type for incrementing numeric columns in table "feature_requests" */
export interface FeatureRequestsIncInput {
  readonly downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  readonly engagement_score?: InputMaybe<Scalars["Int"]["input"]>;
  readonly priority_score?: InputMaybe<Scalars["Int"]["input"]>;
  readonly upvotes?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "feature_requests" */
export interface FeatureRequestsInsertInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  readonly engagement_score?: InputMaybe<Scalars["Int"]["input"]>;
  readonly feature_votes?: InputMaybe<FeatureVotesArrRelInsertInput>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly priority_score?: InputMaybe<Scalars["Int"]["input"]>;
  readonly status?: InputMaybe<Scalars["String"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly upvotes?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate max on columns */
export interface FeatureRequestsMaxFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly downvotes?: Maybe<Scalars["Int"]["output"]>;
  readonly engagement_score?: Maybe<Scalars["Int"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly priority_score?: Maybe<Scalars["Int"]["output"]>;
  readonly status?: Maybe<Scalars["String"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Int"]["output"]>;
}

/** aggregate min on columns */
export interface FeatureRequestsMinFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly downvotes?: Maybe<Scalars["Int"]["output"]>;
  readonly engagement_score?: Maybe<Scalars["Int"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly priority_score?: Maybe<Scalars["Int"]["output"]>;
  readonly status?: Maybe<Scalars["String"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Int"]["output"]>;
}

/** response of any mutation on the table "feature_requests" */
export interface FeatureRequestsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<FeatureRequests>;
}

/** input type for inserting object relation for remote table "feature_requests" */
export interface FeatureRequestsObjRelInsertInput {
  readonly data: FeatureRequestsInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<FeatureRequestsOnConflict>;
}

/** on_conflict condition type for table "feature_requests" */
export interface FeatureRequestsOnConflict {
  readonly constraint: FeatureRequestsConstraint;
  readonly update_columns: ReadonlyArray<FeatureRequestsUpdateColumn>;
  readonly where?: InputMaybe<FeatureRequestsBoolExp>;
}

/** Ordering options when selecting data from "feature_requests". */
export interface FeatureRequestsOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly description?: InputMaybe<OrderBy>;
  readonly downvotes?: InputMaybe<OrderBy>;
  readonly engagement_score?: InputMaybe<OrderBy>;
  readonly feature_votes_aggregate?: InputMaybe<FeatureVotesAggregateOrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly priority_score?: InputMaybe<OrderBy>;
  readonly status?: InputMaybe<OrderBy>;
  readonly title?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly upvotes?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: feature_requests */
export interface FeatureRequestsPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** select columns of table "feature_requests" */
export type FeatureRequestsSelectColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "description"
  /** column name */
  | "downvotes"
  /** column name */
  | "engagement_score"
  /** column name */
  | "id"
  /** column name */
  | "priority_score"
  /** column name */
  | "status"
  /** column name */
  | "title"
  /** column name */
  | "updated_at"
  /** column name */
  | "upvotes";

/** input type for updating data in table "feature_requests" */
export interface FeatureRequestsSetInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  readonly engagement_score?: InputMaybe<Scalars["Int"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly priority_score?: InputMaybe<Scalars["Int"]["input"]>;
  readonly status?: InputMaybe<Scalars["String"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly upvotes?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate stddev on columns */
export interface FeatureRequestsStddevFields {
  readonly downvotes?: Maybe<Scalars["Float"]["output"]>;
  readonly engagement_score?: Maybe<Scalars["Float"]["output"]>;
  readonly priority_score?: Maybe<Scalars["Float"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface FeatureRequestsStddevPopFields {
  readonly downvotes?: Maybe<Scalars["Float"]["output"]>;
  readonly engagement_score?: Maybe<Scalars["Float"]["output"]>;
  readonly priority_score?: Maybe<Scalars["Float"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface FeatureRequestsStddevSampFields {
  readonly downvotes?: Maybe<Scalars["Float"]["output"]>;
  readonly engagement_score?: Maybe<Scalars["Float"]["output"]>;
  readonly priority_score?: Maybe<Scalars["Float"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "feature_requests" */
export interface FeatureRequestsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: FeatureRequestsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface FeatureRequestsStreamCursorValueInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  readonly engagement_score?: InputMaybe<Scalars["Int"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly priority_score?: InputMaybe<Scalars["Int"]["input"]>;
  readonly status?: InputMaybe<Scalars["String"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly upvotes?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate sum on columns */
export interface FeatureRequestsSumFields {
  readonly downvotes?: Maybe<Scalars["Int"]["output"]>;
  readonly engagement_score?: Maybe<Scalars["Int"]["output"]>;
  readonly priority_score?: Maybe<Scalars["Int"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "feature_requests" */
export type FeatureRequestsUpdateColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "description"
  /** column name */
  | "downvotes"
  /** column name */
  | "engagement_score"
  /** column name */
  | "id"
  /** column name */
  | "priority_score"
  /** column name */
  | "status"
  /** column name */
  | "title"
  /** column name */
  | "updated_at"
  /** column name */
  | "upvotes";

export interface FeatureRequestsUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<FeatureRequestsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<FeatureRequestsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: FeatureRequestsBoolExp;
}

/** aggregate var_pop on columns */
export interface FeatureRequestsVarPopFields {
  readonly downvotes?: Maybe<Scalars["Float"]["output"]>;
  readonly engagement_score?: Maybe<Scalars["Float"]["output"]>;
  readonly priority_score?: Maybe<Scalars["Float"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface FeatureRequestsVarSampFields {
  readonly downvotes?: Maybe<Scalars["Float"]["output"]>;
  readonly engagement_score?: Maybe<Scalars["Float"]["output"]>;
  readonly priority_score?: Maybe<Scalars["Float"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface FeatureRequestsVarianceFields {
  readonly downvotes?: Maybe<Scalars["Float"]["output"]>;
  readonly engagement_score?: Maybe<Scalars["Float"]["output"]>;
  readonly priority_score?: Maybe<Scalars["Float"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "feature_votes" */
export interface FeatureVotes {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly feature_id: Scalars["uuid"]["output"];
  /** An object relationship */
  readonly feature_request: FeatureRequests;
  readonly feedback?: Maybe<Scalars["String"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly user_id: Scalars["uuid"]["output"];
  readonly vote_type: Scalars["smallint"]["output"];
}

/** aggregated selection of "feature_votes" */
export interface FeatureVotesAggregate {
  readonly aggregate?: Maybe<FeatureVotesAggregateFields>;
  readonly nodes: ReadonlyArray<FeatureVotes>;
}

export interface FeatureVotesAggregateBoolExp {
  readonly count?: InputMaybe<FeatureVotesAggregateBoolExpCount>;
}

export interface FeatureVotesAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<FeatureVotesSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<FeatureVotesBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "feature_votes" */
export interface FeatureVotesAggregateFields {
  readonly avg?: Maybe<FeatureVotesAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<FeatureVotesMaxFields>;
  readonly min?: Maybe<FeatureVotesMinFields>;
  readonly stddev?: Maybe<FeatureVotesStddevFields>;
  readonly stddev_pop?: Maybe<FeatureVotesStddevPopFields>;
  readonly stddev_samp?: Maybe<FeatureVotesStddevSampFields>;
  readonly sum?: Maybe<FeatureVotesSumFields>;
  readonly var_pop?: Maybe<FeatureVotesVarPopFields>;
  readonly var_samp?: Maybe<FeatureVotesVarSampFields>;
  readonly variance?: Maybe<FeatureVotesVarianceFields>;
}

/** aggregate fields of "feature_votes" */
export type FeatureVotesAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<FeatureVotesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "feature_votes" */
export interface FeatureVotesAggregateOrderBy {
  readonly avg?: InputMaybe<FeatureVotesAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<FeatureVotesMaxOrderBy>;
  readonly min?: InputMaybe<FeatureVotesMinOrderBy>;
  readonly stddev?: InputMaybe<FeatureVotesStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<FeatureVotesStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<FeatureVotesStddevSampOrderBy>;
  readonly sum?: InputMaybe<FeatureVotesSumOrderBy>;
  readonly var_pop?: InputMaybe<FeatureVotesVarPopOrderBy>;
  readonly var_samp?: InputMaybe<FeatureVotesVarSampOrderBy>;
  readonly variance?: InputMaybe<FeatureVotesVarianceOrderBy>;
}

/** input type for inserting array relation for remote table "feature_votes" */
export interface FeatureVotesArrRelInsertInput {
  readonly data: ReadonlyArray<FeatureVotesInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<FeatureVotesOnConflict>;
}

/** aggregate avg on columns */
export interface FeatureVotesAvgFields {
  readonly vote_type?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "feature_votes" */
export interface FeatureVotesAvgOrderBy {
  readonly vote_type?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "feature_votes". All fields are combined with a logical 'AND'. */
export interface FeatureVotesBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<FeatureVotesBoolExp>>;
  readonly _not?: InputMaybe<FeatureVotesBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<FeatureVotesBoolExp>>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly feature_id?: InputMaybe<UuidComparisonExp>;
  readonly feature_request?: InputMaybe<FeatureRequestsBoolExp>;
  readonly feedback?: InputMaybe<StringComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly user_id?: InputMaybe<UuidComparisonExp>;
  readonly vote_type?: InputMaybe<SmallintComparisonExp>;
}

/** unique or primary key constraints on table "feature_votes" */
export type FeatureVotesConstraint =
  /** unique or primary key constraint on columns "id" */
  | "feature_votes_pkey"
  /** unique or primary key constraint on columns "user_id", "feature_id" */
  | "feature_votes_user_feature_unique";

/** input type for incrementing numeric columns in table "feature_votes" */
export interface FeatureVotesIncInput {
  readonly vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
}

/** input type for inserting data into table "feature_votes" */
export interface FeatureVotesInsertInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly feature_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly feature_request?: InputMaybe<FeatureRequestsObjRelInsertInput>;
  readonly feedback?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
}

/** aggregate max on columns */
export interface FeatureVotesMaxFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly feature_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly feedback?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly vote_type?: Maybe<Scalars["smallint"]["output"]>;
}

/** order by max() on columns of table "feature_votes" */
export interface FeatureVotesMaxOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly feature_id?: InputMaybe<OrderBy>;
  readonly feedback?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
  readonly vote_type?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface FeatureVotesMinFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly feature_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly feedback?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly vote_type?: Maybe<Scalars["smallint"]["output"]>;
}

/** order by min() on columns of table "feature_votes" */
export interface FeatureVotesMinOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly feature_id?: InputMaybe<OrderBy>;
  readonly feedback?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
  readonly vote_type?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "feature_votes" */
export interface FeatureVotesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<FeatureVotes>;
}

/** on_conflict condition type for table "feature_votes" */
export interface FeatureVotesOnConflict {
  readonly constraint: FeatureVotesConstraint;
  readonly update_columns: ReadonlyArray<FeatureVotesUpdateColumn>;
  readonly where?: InputMaybe<FeatureVotesBoolExp>;
}

/** Ordering options when selecting data from "feature_votes". */
export interface FeatureVotesOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly feature_id?: InputMaybe<OrderBy>;
  readonly feature_request?: InputMaybe<FeatureRequestsOrderBy>;
  readonly feedback?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
  readonly vote_type?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: feature_votes */
export interface FeatureVotesPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** select columns of table "feature_votes" */
export type FeatureVotesSelectColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "feature_id"
  /** column name */
  | "feedback"
  /** column name */
  | "id"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id"
  /** column name */
  | "vote_type";

/** input type for updating data in table "feature_votes" */
export interface FeatureVotesSetInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly feature_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly feedback?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
}

/** aggregate stddev on columns */
export interface FeatureVotesStddevFields {
  readonly vote_type?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "feature_votes" */
export interface FeatureVotesStddevOrderBy {
  readonly vote_type?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface FeatureVotesStddevPopFields {
  readonly vote_type?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "feature_votes" */
export interface FeatureVotesStddevPopOrderBy {
  readonly vote_type?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface FeatureVotesStddevSampFields {
  readonly vote_type?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "feature_votes" */
export interface FeatureVotesStddevSampOrderBy {
  readonly vote_type?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "feature_votes" */
export interface FeatureVotesStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: FeatureVotesStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface FeatureVotesStreamCursorValueInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly feature_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly feedback?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
}

/** aggregate sum on columns */
export interface FeatureVotesSumFields {
  readonly vote_type?: Maybe<Scalars["smallint"]["output"]>;
}

/** order by sum() on columns of table "feature_votes" */
export interface FeatureVotesSumOrderBy {
  readonly vote_type?: InputMaybe<OrderBy>;
}

/** update columns of table "feature_votes" */
export type FeatureVotesUpdateColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "feature_id"
  /** column name */
  | "feedback"
  /** column name */
  | "id"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id"
  /** column name */
  | "vote_type";

export interface FeatureVotesUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<FeatureVotesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<FeatureVotesSetInput>;
  /** filter the rows which have to be updated */
  readonly where: FeatureVotesBoolExp;
}

/** aggregate var_pop on columns */
export interface FeatureVotesVarPopFields {
  readonly vote_type?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "feature_votes" */
export interface FeatureVotesVarPopOrderBy {
  readonly vote_type?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface FeatureVotesVarSampFields {
  readonly vote_type?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "feature_votes" */
export interface FeatureVotesVarSampOrderBy {
  readonly vote_type?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface FeatureVotesVarianceFields {
  readonly vote_type?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "feature_votes" */
export interface FeatureVotesVarianceOrderBy {
  readonly vote_type?: InputMaybe<OrderBy>;
}

/** Categories For Custom Feeds */
export interface FeedCategories {
  /** An object relationship */
  readonly category?: Maybe<Categories>;
  readonly category_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly created_at: Scalars["timestamptz"]["output"];
  /** An object relationship */
  readonly feed?: Maybe<Feeds>;
  readonly feed_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly id: Scalars["bigint"]["output"];
}

/** aggregated selection of "feed_categories" */
export interface FeedCategoriesAggregate {
  readonly aggregate?: Maybe<FeedCategoriesAggregateFields>;
  readonly nodes: ReadonlyArray<FeedCategories>;
}

export interface FeedCategoriesAggregateBoolExp {
  readonly count?: InputMaybe<FeedCategoriesAggregateBoolExpCount>;
}

export interface FeedCategoriesAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<FeedCategoriesSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<FeedCategoriesBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "feed_categories" */
export interface FeedCategoriesAggregateFields {
  readonly avg?: Maybe<FeedCategoriesAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<FeedCategoriesMaxFields>;
  readonly min?: Maybe<FeedCategoriesMinFields>;
  readonly stddev?: Maybe<FeedCategoriesStddevFields>;
  readonly stddev_pop?: Maybe<FeedCategoriesStddevPopFields>;
  readonly stddev_samp?: Maybe<FeedCategoriesStddevSampFields>;
  readonly sum?: Maybe<FeedCategoriesSumFields>;
  readonly var_pop?: Maybe<FeedCategoriesVarPopFields>;
  readonly var_samp?: Maybe<FeedCategoriesVarSampFields>;
  readonly variance?: Maybe<FeedCategoriesVarianceFields>;
}

/** aggregate fields of "feed_categories" */
export type FeedCategoriesAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<FeedCategoriesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "feed_categories" */
export interface FeedCategoriesAggregateOrderBy {
  readonly avg?: InputMaybe<FeedCategoriesAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<FeedCategoriesMaxOrderBy>;
  readonly min?: InputMaybe<FeedCategoriesMinOrderBy>;
  readonly stddev?: InputMaybe<FeedCategoriesStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<FeedCategoriesStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<FeedCategoriesStddevSampOrderBy>;
  readonly sum?: InputMaybe<FeedCategoriesSumOrderBy>;
  readonly var_pop?: InputMaybe<FeedCategoriesVarPopOrderBy>;
  readonly var_samp?: InputMaybe<FeedCategoriesVarSampOrderBy>;
  readonly variance?: InputMaybe<FeedCategoriesVarianceOrderBy>;
}

/** input type for inserting array relation for remote table "feed_categories" */
export interface FeedCategoriesArrRelInsertInput {
  readonly data: ReadonlyArray<FeedCategoriesInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<FeedCategoriesOnConflict>;
}

/** aggregate avg on columns */
export interface FeedCategoriesAvgFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "feed_categories" */
export interface FeedCategoriesAvgOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "feed_categories". All fields are combined with a logical 'AND'. */
export interface FeedCategoriesBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<FeedCategoriesBoolExp>>;
  readonly _not?: InputMaybe<FeedCategoriesBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<FeedCategoriesBoolExp>>;
  readonly category?: InputMaybe<CategoriesBoolExp>;
  readonly category_id?: InputMaybe<BigintComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly feed?: InputMaybe<FeedsBoolExp>;
  readonly feed_id?: InputMaybe<UuidComparisonExp>;
  readonly id?: InputMaybe<BigintComparisonExp>;
}

/** unique or primary key constraints on table "feed_categories" */
export type FeedCategoriesConstraint =
  /** unique or primary key constraint on columns "id" */
  "feed_categories_pkey";

/** input type for incrementing numeric columns in table "feed_categories" */
export interface FeedCategoriesIncInput {
  readonly category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** input type for inserting data into table "feed_categories" */
export interface FeedCategoriesInsertInput {
  readonly category?: InputMaybe<CategoriesObjRelInsertInput>;
  readonly category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly feed?: InputMaybe<FeedsObjRelInsertInput>;
  readonly feed_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** aggregate max on columns */
export interface FeedCategoriesMaxFields {
  readonly category_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly feed_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
}

/** order by max() on columns of table "feed_categories" */
export interface FeedCategoriesMaxOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly feed_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface FeedCategoriesMinFields {
  readonly category_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly feed_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
}

/** order by min() on columns of table "feed_categories" */
export interface FeedCategoriesMinOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly feed_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "feed_categories" */
export interface FeedCategoriesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<FeedCategories>;
}

/** on_conflict condition type for table "feed_categories" */
export interface FeedCategoriesOnConflict {
  readonly constraint: FeedCategoriesConstraint;
  readonly update_columns: ReadonlyArray<FeedCategoriesUpdateColumn>;
  readonly where?: InputMaybe<FeedCategoriesBoolExp>;
}

/** Ordering options when selecting data from "feed_categories". */
export interface FeedCategoriesOrderBy {
  readonly category?: InputMaybe<CategoriesOrderBy>;
  readonly category_id?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly feed?: InputMaybe<FeedsOrderBy>;
  readonly feed_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: feed_categories */
export interface FeedCategoriesPkColumnsInput {
  readonly id: Scalars["bigint"]["input"];
}

/** select columns of table "feed_categories" */
export type FeedCategoriesSelectColumn =
  /** column name */
  | "category_id"
  /** column name */
  | "created_at"
  /** column name */
  | "feed_id"
  /** column name */
  | "id";

/** input type for updating data in table "feed_categories" */
export interface FeedCategoriesSetInput {
  readonly category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly feed_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** aggregate stddev on columns */
export interface FeedCategoriesStddevFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "feed_categories" */
export interface FeedCategoriesStddevOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface FeedCategoriesStddevPopFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "feed_categories" */
export interface FeedCategoriesStddevPopOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface FeedCategoriesStddevSampFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "feed_categories" */
export interface FeedCategoriesStddevSampOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "feed_categories" */
export interface FeedCategoriesStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: FeedCategoriesStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface FeedCategoriesStreamCursorValueInput {
  readonly category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly feed_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** aggregate sum on columns */
export interface FeedCategoriesSumFields {
  readonly category_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
}

/** order by sum() on columns of table "feed_categories" */
export interface FeedCategoriesSumOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** update columns of table "feed_categories" */
export type FeedCategoriesUpdateColumn =
  /** column name */
  | "category_id"
  /** column name */
  | "created_at"
  /** column name */
  | "feed_id"
  /** column name */
  | "id";

export interface FeedCategoriesUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<FeedCategoriesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<FeedCategoriesSetInput>;
  /** filter the rows which have to be updated */
  readonly where: FeedCategoriesBoolExp;
}

/** aggregate var_pop on columns */
export interface FeedCategoriesVarPopFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "feed_categories" */
export interface FeedCategoriesVarPopOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface FeedCategoriesVarSampFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "feed_categories" */
export interface FeedCategoriesVarSampOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface FeedCategoriesVarianceFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "feed_categories" */
export interface FeedCategoriesVarianceOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** columns and relationships of "feed_sources" */
export interface FeedSources {
  /** An object relationship */
  readonly content_source?: Maybe<ContentSources>;
  readonly content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly created_at: Scalars["timestamptz"]["output"];
  /** An object relationship */
  readonly feed?: Maybe<Feeds>;
  readonly feed_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly id: Scalars["bigint"]["output"];
}

/** aggregated selection of "feed_sources" */
export interface FeedSourcesAggregate {
  readonly aggregate?: Maybe<FeedSourcesAggregateFields>;
  readonly nodes: ReadonlyArray<FeedSources>;
}

export interface FeedSourcesAggregateBoolExp {
  readonly count?: InputMaybe<FeedSourcesAggregateBoolExpCount>;
}

export interface FeedSourcesAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<FeedSourcesSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<FeedSourcesBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "feed_sources" */
export interface FeedSourcesAggregateFields {
  readonly avg?: Maybe<FeedSourcesAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<FeedSourcesMaxFields>;
  readonly min?: Maybe<FeedSourcesMinFields>;
  readonly stddev?: Maybe<FeedSourcesStddevFields>;
  readonly stddev_pop?: Maybe<FeedSourcesStddevPopFields>;
  readonly stddev_samp?: Maybe<FeedSourcesStddevSampFields>;
  readonly sum?: Maybe<FeedSourcesSumFields>;
  readonly var_pop?: Maybe<FeedSourcesVarPopFields>;
  readonly var_samp?: Maybe<FeedSourcesVarSampFields>;
  readonly variance?: Maybe<FeedSourcesVarianceFields>;
}

/** aggregate fields of "feed_sources" */
export type FeedSourcesAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<FeedSourcesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "feed_sources" */
export interface FeedSourcesAggregateOrderBy {
  readonly avg?: InputMaybe<FeedSourcesAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<FeedSourcesMaxOrderBy>;
  readonly min?: InputMaybe<FeedSourcesMinOrderBy>;
  readonly stddev?: InputMaybe<FeedSourcesStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<FeedSourcesStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<FeedSourcesStddevSampOrderBy>;
  readonly sum?: InputMaybe<FeedSourcesSumOrderBy>;
  readonly var_pop?: InputMaybe<FeedSourcesVarPopOrderBy>;
  readonly var_samp?: InputMaybe<FeedSourcesVarSampOrderBy>;
  readonly variance?: InputMaybe<FeedSourcesVarianceOrderBy>;
}

/** input type for inserting array relation for remote table "feed_sources" */
export interface FeedSourcesArrRelInsertInput {
  readonly data: ReadonlyArray<FeedSourcesInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<FeedSourcesOnConflict>;
}

/** aggregate avg on columns */
export interface FeedSourcesAvgFields {
  readonly content_source_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "feed_sources" */
export interface FeedSourcesAvgOrderBy {
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "feed_sources". All fields are combined with a logical 'AND'. */
export interface FeedSourcesBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<FeedSourcesBoolExp>>;
  readonly _not?: InputMaybe<FeedSourcesBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<FeedSourcesBoolExp>>;
  readonly content_source?: InputMaybe<ContentSourcesBoolExp>;
  readonly content_source_id?: InputMaybe<BigintComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly feed?: InputMaybe<FeedsBoolExp>;
  readonly feed_id?: InputMaybe<UuidComparisonExp>;
  readonly id?: InputMaybe<BigintComparisonExp>;
}

/** unique or primary key constraints on table "feed_sources" */
export type FeedSourcesConstraint =
  /** unique or primary key constraint on columns "id" */
  "feed_sources_pkey";

/** input type for incrementing numeric columns in table "feed_sources" */
export interface FeedSourcesIncInput {
  readonly content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** input type for inserting data into table "feed_sources" */
export interface FeedSourcesInsertInput {
  readonly content_source?: InputMaybe<ContentSourcesObjRelInsertInput>;
  readonly content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly feed?: InputMaybe<FeedsObjRelInsertInput>;
  readonly feed_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** aggregate max on columns */
export interface FeedSourcesMaxFields {
  readonly content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly feed_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
}

/** order by max() on columns of table "feed_sources" */
export interface FeedSourcesMaxOrderBy {
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly feed_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface FeedSourcesMinFields {
  readonly content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly feed_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
}

/** order by min() on columns of table "feed_sources" */
export interface FeedSourcesMinOrderBy {
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly feed_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "feed_sources" */
export interface FeedSourcesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<FeedSources>;
}

/** on_conflict condition type for table "feed_sources" */
export interface FeedSourcesOnConflict {
  readonly constraint: FeedSourcesConstraint;
  readonly update_columns: ReadonlyArray<FeedSourcesUpdateColumn>;
  readonly where?: InputMaybe<FeedSourcesBoolExp>;
}

/** Ordering options when selecting data from "feed_sources". */
export interface FeedSourcesOrderBy {
  readonly content_source?: InputMaybe<ContentSourcesOrderBy>;
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly feed?: InputMaybe<FeedsOrderBy>;
  readonly feed_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: feed_sources */
export interface FeedSourcesPkColumnsInput {
  readonly id: Scalars["bigint"]["input"];
}

/** select columns of table "feed_sources" */
export type FeedSourcesSelectColumn =
  /** column name */
  | "content_source_id"
  /** column name */
  | "created_at"
  /** column name */
  | "feed_id"
  /** column name */
  | "id";

/** input type for updating data in table "feed_sources" */
export interface FeedSourcesSetInput {
  readonly content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly feed_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** aggregate stddev on columns */
export interface FeedSourcesStddevFields {
  readonly content_source_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "feed_sources" */
export interface FeedSourcesStddevOrderBy {
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface FeedSourcesStddevPopFields {
  readonly content_source_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "feed_sources" */
export interface FeedSourcesStddevPopOrderBy {
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface FeedSourcesStddevSampFields {
  readonly content_source_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "feed_sources" */
export interface FeedSourcesStddevSampOrderBy {
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "feed_sources" */
export interface FeedSourcesStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: FeedSourcesStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface FeedSourcesStreamCursorValueInput {
  readonly content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly feed_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** aggregate sum on columns */
export interface FeedSourcesSumFields {
  readonly content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
}

/** order by sum() on columns of table "feed_sources" */
export interface FeedSourcesSumOrderBy {
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** update columns of table "feed_sources" */
export type FeedSourcesUpdateColumn =
  /** column name */
  | "content_source_id"
  /** column name */
  | "created_at"
  /** column name */
  | "feed_id";

export interface FeedSourcesUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<FeedSourcesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<FeedSourcesSetInput>;
  /** filter the rows which have to be updated */
  readonly where: FeedSourcesBoolExp;
}

/** aggregate var_pop on columns */
export interface FeedSourcesVarPopFields {
  readonly content_source_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "feed_sources" */
export interface FeedSourcesVarPopOrderBy {
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface FeedSourcesVarSampFields {
  readonly content_source_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "feed_sources" */
export interface FeedSourcesVarSampOrderBy {
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface FeedSourcesVarianceFields {
  readonly content_source_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "feed_sources" */
export interface FeedSourcesVarianceOrderBy {
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

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

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

/** columns and relationships of "feedbacks" */
export interface Feedbacks {
  readonly created_at: Scalars["timestamptz"]["output"];
  readonly device_info?: Maybe<Scalars["String"]["output"]>;
  readonly feedback_status?: Maybe<Scalars["feedback_status"]["output"]>;
  readonly feedback_type?: Maybe<Scalars["feedback_type"]["output"]>;
  readonly id: Scalars["Int"]["output"];
  readonly message: Scalars["String"]["output"];
  readonly page_identifier: Scalars["String"]["output"];
  readonly rating?: Maybe<Scalars["Int"]["output"]>;
  readonly resolution_comment?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at: Scalars["timestamptz"]["output"];
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
  /** An object relationship */
  readonly user_profile?: Maybe<UserProfiles>;
}

/** aggregated selection of "feedbacks" */
export interface FeedbacksAggregate {
  readonly aggregate?: Maybe<FeedbacksAggregateFields>;
  readonly nodes: ReadonlyArray<Feedbacks>;
}

export interface FeedbacksAggregateBoolExp {
  readonly count?: InputMaybe<FeedbacksAggregateBoolExpCount>;
}

export interface FeedbacksAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<FeedbacksSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<FeedbacksBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "feedbacks" */
export interface FeedbacksAggregateFields {
  readonly avg?: Maybe<FeedbacksAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<FeedbacksMaxFields>;
  readonly min?: Maybe<FeedbacksMinFields>;
  readonly stddev?: Maybe<FeedbacksStddevFields>;
  readonly stddev_pop?: Maybe<FeedbacksStddevPopFields>;
  readonly stddev_samp?: Maybe<FeedbacksStddevSampFields>;
  readonly sum?: Maybe<FeedbacksSumFields>;
  readonly var_pop?: Maybe<FeedbacksVarPopFields>;
  readonly var_samp?: Maybe<FeedbacksVarSampFields>;
  readonly variance?: Maybe<FeedbacksVarianceFields>;
}

/** aggregate fields of "feedbacks" */
export type FeedbacksAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<FeedbacksSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "feedbacks" */
export interface FeedbacksAggregateOrderBy {
  readonly avg?: InputMaybe<FeedbacksAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<FeedbacksMaxOrderBy>;
  readonly min?: InputMaybe<FeedbacksMinOrderBy>;
  readonly stddev?: InputMaybe<FeedbacksStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<FeedbacksStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<FeedbacksStddevSampOrderBy>;
  readonly sum?: InputMaybe<FeedbacksSumOrderBy>;
  readonly var_pop?: InputMaybe<FeedbacksVarPopOrderBy>;
  readonly var_samp?: InputMaybe<FeedbacksVarSampOrderBy>;
  readonly variance?: InputMaybe<FeedbacksVarianceOrderBy>;
}

/** input type for inserting array relation for remote table "feedbacks" */
export interface FeedbacksArrRelInsertInput {
  readonly data: ReadonlyArray<FeedbacksInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<FeedbacksOnConflict>;
}

/** aggregate avg on columns */
export interface FeedbacksAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly rating?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "feedbacks" */
export interface FeedbacksAvgOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly rating?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "feedbacks". All fields are combined with a logical 'AND'. */
export interface FeedbacksBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<FeedbacksBoolExp>>;
  readonly _not?: InputMaybe<FeedbacksBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<FeedbacksBoolExp>>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly device_info?: InputMaybe<StringComparisonExp>;
  readonly feedback_status?: InputMaybe<FeedbackStatusComparisonExp>;
  readonly feedback_type?: InputMaybe<FeedbackTypeComparisonExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly message?: InputMaybe<StringComparisonExp>;
  readonly page_identifier?: InputMaybe<StringComparisonExp>;
  readonly rating?: InputMaybe<IntComparisonExp>;
  readonly resolution_comment?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly user_id?: InputMaybe<UuidComparisonExp>;
  readonly user_profile?: InputMaybe<UserProfilesBoolExp>;
}

/** unique or primary key constraints on table "feedbacks" */
export type FeedbacksConstraint =
  /** unique or primary key constraint on columns "id" */
  "feedback_pkey";

/** input type for incrementing numeric columns in table "feedbacks" */
export interface FeedbacksIncInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly rating?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "feedbacks" */
export interface FeedbacksInsertInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly device_info?: InputMaybe<Scalars["String"]["input"]>;
  readonly feedback_status?: InputMaybe<Scalars["feedback_status"]["input"]>;
  readonly feedback_type?: InputMaybe<Scalars["feedback_type"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly message?: InputMaybe<Scalars["String"]["input"]>;
  readonly page_identifier?: InputMaybe<Scalars["String"]["input"]>;
  readonly rating?: InputMaybe<Scalars["Int"]["input"]>;
  readonly resolution_comment?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
}

/** aggregate max on columns */
export interface FeedbacksMaxFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly device_info?: Maybe<Scalars["String"]["output"]>;
  readonly feedback_status?: Maybe<Scalars["feedback_status"]["output"]>;
  readonly feedback_type?: Maybe<Scalars["feedback_type"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly message?: Maybe<Scalars["String"]["output"]>;
  readonly page_identifier?: Maybe<Scalars["String"]["output"]>;
  readonly rating?: Maybe<Scalars["Int"]["output"]>;
  readonly resolution_comment?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** order by max() on columns of table "feedbacks" */
export interface FeedbacksMaxOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly device_info?: InputMaybe<OrderBy>;
  readonly feedback_status?: InputMaybe<OrderBy>;
  readonly feedback_type?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly message?: InputMaybe<OrderBy>;
  readonly page_identifier?: InputMaybe<OrderBy>;
  readonly rating?: InputMaybe<OrderBy>;
  readonly resolution_comment?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface FeedbacksMinFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly device_info?: Maybe<Scalars["String"]["output"]>;
  readonly feedback_status?: Maybe<Scalars["feedback_status"]["output"]>;
  readonly feedback_type?: Maybe<Scalars["feedback_type"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly message?: Maybe<Scalars["String"]["output"]>;
  readonly page_identifier?: Maybe<Scalars["String"]["output"]>;
  readonly rating?: Maybe<Scalars["Int"]["output"]>;
  readonly resolution_comment?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** order by min() on columns of table "feedbacks" */
export interface FeedbacksMinOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly device_info?: InputMaybe<OrderBy>;
  readonly feedback_status?: InputMaybe<OrderBy>;
  readonly feedback_type?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly message?: InputMaybe<OrderBy>;
  readonly page_identifier?: InputMaybe<OrderBy>;
  readonly rating?: InputMaybe<OrderBy>;
  readonly resolution_comment?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "feedbacks" */
export interface FeedbacksMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Feedbacks>;
}

/** on_conflict condition type for table "feedbacks" */
export interface FeedbacksOnConflict {
  readonly constraint: FeedbacksConstraint;
  readonly update_columns: ReadonlyArray<FeedbacksUpdateColumn>;
  readonly where?: InputMaybe<FeedbacksBoolExp>;
}

/** Ordering options when selecting data from "feedbacks". */
export interface FeedbacksOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly device_info?: InputMaybe<OrderBy>;
  readonly feedback_status?: InputMaybe<OrderBy>;
  readonly feedback_type?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly message?: InputMaybe<OrderBy>;
  readonly page_identifier?: InputMaybe<OrderBy>;
  readonly rating?: InputMaybe<OrderBy>;
  readonly resolution_comment?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
  readonly user_profile?: InputMaybe<UserProfilesOrderBy>;
}

/** primary key columns input for table: feedbacks */
export interface FeedbacksPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** select columns of table "feedbacks" */
export type FeedbacksSelectColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "device_info"
  /** column name */
  | "feedback_status"
  /** column name */
  | "feedback_type"
  /** column name */
  | "id"
  /** column name */
  | "message"
  /** column name */
  | "page_identifier"
  /** column name */
  | "rating"
  /** column name */
  | "resolution_comment"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

/** input type for updating data in table "feedbacks" */
export interface FeedbacksSetInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly device_info?: InputMaybe<Scalars["String"]["input"]>;
  readonly feedback_status?: InputMaybe<Scalars["feedback_status"]["input"]>;
  readonly feedback_type?: InputMaybe<Scalars["feedback_type"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly message?: InputMaybe<Scalars["String"]["input"]>;
  readonly page_identifier?: InputMaybe<Scalars["String"]["input"]>;
  readonly rating?: InputMaybe<Scalars["Int"]["input"]>;
  readonly resolution_comment?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** aggregate stddev on columns */
export interface FeedbacksStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly rating?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "feedbacks" */
export interface FeedbacksStddevOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly rating?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface FeedbacksStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly rating?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "feedbacks" */
export interface FeedbacksStddevPopOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly rating?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface FeedbacksStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly rating?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "feedbacks" */
export interface FeedbacksStddevSampOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly rating?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "feedbacks" */
export interface FeedbacksStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: FeedbacksStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface FeedbacksStreamCursorValueInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly device_info?: InputMaybe<Scalars["String"]["input"]>;
  readonly feedback_status?: InputMaybe<Scalars["feedback_status"]["input"]>;
  readonly feedback_type?: InputMaybe<Scalars["feedback_type"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly message?: InputMaybe<Scalars["String"]["input"]>;
  readonly page_identifier?: InputMaybe<Scalars["String"]["input"]>;
  readonly rating?: InputMaybe<Scalars["Int"]["input"]>;
  readonly resolution_comment?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** aggregate sum on columns */
export interface FeedbacksSumFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly rating?: Maybe<Scalars["Int"]["output"]>;
}

/** order by sum() on columns of table "feedbacks" */
export interface FeedbacksSumOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly rating?: InputMaybe<OrderBy>;
}

/** update columns of table "feedbacks" */
export type FeedbacksUpdateColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "device_info"
  /** column name */
  | "feedback_status"
  /** column name */
  | "feedback_type"
  /** column name */
  | "id"
  /** column name */
  | "message"
  /** column name */
  | "page_identifier"
  /** column name */
  | "rating"
  /** column name */
  | "resolution_comment"
  /** column name */
  | "updated_at"
  /** column name */
  | "user_id";

export interface FeedbacksUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<FeedbacksIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<FeedbacksSetInput>;
  /** filter the rows which have to be updated */
  readonly where: FeedbacksBoolExp;
}

/** aggregate var_pop on columns */
export interface FeedbacksVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly rating?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "feedbacks" */
export interface FeedbacksVarPopOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly rating?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface FeedbacksVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly rating?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "feedbacks" */
export interface FeedbacksVarSampOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly rating?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface FeedbacksVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly rating?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "feedbacks" */
export interface FeedbacksVarianceOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly rating?: InputMaybe<OrderBy>;
}

/** Custom Feeds For Users */
export interface Feeds {
  readonly created_at: Scalars["timestamptz"]["output"];
  /** An array relationship */
  readonly feed_categories: ReadonlyArray<FeedCategories>;
  /** An aggregate relationship */
  readonly feed_categories_aggregate: FeedCategoriesAggregate;
  /** An array relationship */
  readonly feed_sources: ReadonlyArray<FeedSources>;
  /** An aggregate relationship */
  readonly feed_sources_aggregate: FeedSourcesAggregate;
  readonly id: Scalars["uuid"]["output"];
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
  /** An object relationship */
  readonly user_profile?: Maybe<UserProfiles>;
}

/** Custom Feeds For Users */
export type FeedsFeedCategoriesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedCategoriesOrderBy>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

/** Custom Feeds For Users */
export type FeedsFeedCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedCategoriesOrderBy>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

/** Custom Feeds For Users */
export type FeedsFeedSourcesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

/** Custom Feeds For Users */
export type FeedsFeedSourcesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

/** aggregated selection of "feeds" */
export interface FeedsAggregate {
  readonly aggregate?: Maybe<FeedsAggregateFields>;
  readonly nodes: ReadonlyArray<Feeds>;
}

export interface FeedsAggregateBoolExp {
  readonly count?: InputMaybe<FeedsAggregateBoolExpCount>;
}

export interface FeedsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<FeedsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<FeedsBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "feeds" */
export interface FeedsAggregateFields {
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<FeedsMaxFields>;
  readonly min?: Maybe<FeedsMinFields>;
}

/** aggregate fields of "feeds" */
export type FeedsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<FeedsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "feeds" */
export interface FeedsAggregateOrderBy {
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<FeedsMaxOrderBy>;
  readonly min?: InputMaybe<FeedsMinOrderBy>;
}

/** input type for inserting array relation for remote table "feeds" */
export interface FeedsArrRelInsertInput {
  readonly data: ReadonlyArray<FeedsInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<FeedsOnConflict>;
}

/** Boolean expression to filter rows from the table "feeds". All fields are combined with a logical 'AND'. */
export interface FeedsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<FeedsBoolExp>>;
  readonly _not?: InputMaybe<FeedsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<FeedsBoolExp>>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly feed_categories?: InputMaybe<FeedCategoriesBoolExp>;
  readonly feed_categories_aggregate?: InputMaybe<FeedCategoriesAggregateBoolExp>;
  readonly feed_sources?: InputMaybe<FeedSourcesBoolExp>;
  readonly feed_sources_aggregate?: InputMaybe<FeedSourcesAggregateBoolExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly name?: InputMaybe<StringComparisonExp>;
  readonly user_id?: InputMaybe<UuidComparisonExp>;
  readonly user_profile?: InputMaybe<UserProfilesBoolExp>;
}

/** unique or primary key constraints on table "feeds" */
export type FeedsConstraint =
  /** unique or primary key constraint on columns "id" */
  "feeds_pkey";

/** input type for inserting data into table "feeds" */
export interface FeedsInsertInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly feed_categories?: InputMaybe<FeedCategoriesArrRelInsertInput>;
  readonly feed_sources?: InputMaybe<FeedSourcesArrRelInsertInput>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
}

/** aggregate max on columns */
export interface FeedsMaxFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** order by max() on columns of table "feeds" */
export interface FeedsMaxOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly name?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface FeedsMinFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** order by min() on columns of table "feeds" */
export interface FeedsMinOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly name?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "feeds" */
export interface FeedsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Feeds>;
}

/** input type for inserting object relation for remote table "feeds" */
export interface FeedsObjRelInsertInput {
  readonly data: FeedsInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<FeedsOnConflict>;
}

/** on_conflict condition type for table "feeds" */
export interface FeedsOnConflict {
  readonly constraint: FeedsConstraint;
  readonly update_columns: ReadonlyArray<FeedsUpdateColumn>;
  readonly where?: InputMaybe<FeedsBoolExp>;
}

/** Ordering options when selecting data from "feeds". */
export interface FeedsOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly feed_categories_aggregate?: InputMaybe<FeedCategoriesAggregateOrderBy>;
  readonly feed_sources_aggregate?: InputMaybe<FeedSourcesAggregateOrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly name?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
  readonly user_profile?: InputMaybe<UserProfilesOrderBy>;
}

/** primary key columns input for table: feeds */
export interface FeedsPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** select columns of table "feeds" */
export type FeedsSelectColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "name"
  /** column name */
  | "user_id";

/** input type for updating data in table "feeds" */
export interface FeedsSetInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** Streaming cursor of the table "feeds" */
export interface FeedsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: FeedsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface FeedsStreamCursorValueInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** update columns of table "feeds" */
export type FeedsUpdateColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "name"
  /** column name */
  | "user_id";

export interface FeedsUpdates {
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<FeedsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: FeedsBoolExp;
}

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

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

/** columns and relationships of "follows" */
export interface Follows {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly followed_entity: Scalars["followed_entity"]["output"];
  readonly followed_id: Scalars["uuid"]["output"];
  readonly id: Scalars["uuid"]["output"];
  readonly user_id: Scalars["uuid"]["output"];
  /** An object relationship */
  readonly user_profile: UserProfiles;
}

/** aggregated selection of "follows" */
export interface FollowsAggregate {
  readonly aggregate?: Maybe<FollowsAggregateFields>;
  readonly nodes: ReadonlyArray<Follows>;
}

export interface FollowsAggregateBoolExp {
  readonly count?: InputMaybe<FollowsAggregateBoolExpCount>;
}

export interface FollowsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<FollowsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<FollowsBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "follows" */
export interface FollowsAggregateFields {
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<FollowsMaxFields>;
  readonly min?: Maybe<FollowsMinFields>;
}

/** aggregate fields of "follows" */
export type FollowsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<FollowsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "follows" */
export interface FollowsAggregateOrderBy {
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<FollowsMaxOrderBy>;
  readonly min?: InputMaybe<FollowsMinOrderBy>;
}

/** input type for inserting array relation for remote table "follows" */
export interface FollowsArrRelInsertInput {
  readonly data: ReadonlyArray<FollowsInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<FollowsOnConflict>;
}

/** Boolean expression to filter rows from the table "follows". All fields are combined with a logical 'AND'. */
export interface FollowsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<FollowsBoolExp>>;
  readonly _not?: InputMaybe<FollowsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<FollowsBoolExp>>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly followed_entity?: InputMaybe<FollowedEntityComparisonExp>;
  readonly followed_id?: InputMaybe<UuidComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly user_id?: InputMaybe<UuidComparisonExp>;
  readonly user_profile?: InputMaybe<UserProfilesBoolExp>;
}

/** unique or primary key constraints on table "follows" */
export type FollowsConstraint =
  /** unique or primary key constraint on columns "id" */
  | "follows_pkey"
  /** unique or primary key constraint on columns "user_id", "followed_entity", "followed_id" */
  | "follows_unique_follower_following_idx";

/** input type for inserting data into table "follows" */
export interface FollowsInsertInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly followed_entity?: InputMaybe<Scalars["followed_entity"]["input"]>;
  readonly followed_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
}

/** aggregate max on columns */
export interface FollowsMaxFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly followed_entity?: Maybe<Scalars["followed_entity"]["output"]>;
  readonly followed_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** order by max() on columns of table "follows" */
export interface FollowsMaxOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly followed_entity?: InputMaybe<OrderBy>;
  readonly followed_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface FollowsMinFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly followed_entity?: Maybe<Scalars["followed_entity"]["output"]>;
  readonly followed_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** order by min() on columns of table "follows" */
export interface FollowsMinOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly followed_entity?: InputMaybe<OrderBy>;
  readonly followed_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "follows" */
export interface FollowsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Follows>;
}

/** on_conflict condition type for table "follows" */
export interface FollowsOnConflict {
  readonly constraint: FollowsConstraint;
  readonly update_columns: ReadonlyArray<FollowsUpdateColumn>;
  readonly where?: InputMaybe<FollowsBoolExp>;
}

/** Ordering options when selecting data from "follows". */
export interface FollowsOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly followed_entity?: InputMaybe<OrderBy>;
  readonly followed_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
  readonly user_profile?: InputMaybe<UserProfilesOrderBy>;
}

/** primary key columns input for table: follows */
export interface FollowsPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** select columns of table "follows" */
export type FollowsSelectColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "followed_entity"
  /** column name */
  | "followed_id"
  /** column name */
  | "id"
  /** column name */
  | "user_id";

/** input type for updating data in table "follows" */
export interface FollowsSetInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly followed_entity?: InputMaybe<Scalars["followed_entity"]["input"]>;
  readonly followed_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** Streaming cursor of the table "follows" */
export interface FollowsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: FollowsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface FollowsStreamCursorValueInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly followed_entity?: InputMaybe<Scalars["followed_entity"]["input"]>;
  readonly followed_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** update columns of table "follows" */
export type FollowsUpdateColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "followed_entity"
  /** column name */
  | "followed_id"
  /** column name */
  | "id"
  /** column name */
  | "user_id";

export interface FollowsUpdates {
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<FollowsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: FollowsBoolExp;
}

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

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

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

export interface JsonbCastExp {
  readonly String?: InputMaybe<StringComparisonExp>;
}

/** Boolean expression to compare columns of type "jsonb". All fields are combined with logical 'AND'. */
export interface JsonbComparisonExp {
  readonly _cast?: InputMaybe<JsonbCastExp>;
  /** is the column contained in the given json value */
  readonly _contained_in?: InputMaybe<Scalars["jsonb"]["input"]>;
  /** does the column contain the given json value at the top level */
  readonly _contains?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly _eq?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly _gt?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly _gte?: InputMaybe<Scalars["jsonb"]["input"]>;
  /** does the string exist as a top-level key in the column */
  readonly _has_key?: InputMaybe<Scalars["String"]["input"]>;
  /** do all of these strings exist as top-level keys in the column */
  readonly _has_keys_all?: InputMaybe<
    ReadonlyArray<Scalars["String"]["input"]>
  >;
  /** do any of these strings exist as top-level keys in the column */
  readonly _has_keys_any?: InputMaybe<
    ReadonlyArray<Scalars["String"]["input"]>
  >;
  readonly _in?: InputMaybe<ReadonlyArray<Scalars["jsonb"]["input"]>>;
  readonly _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly _lt?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly _lte?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly _neq?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly _nin?: InputMaybe<ReadonlyArray<Scalars["jsonb"]["input"]>>;
}

/** Boolean expression to compare columns of type "ltree". All fields are combined with logical 'AND'. */
export interface LtreeComparisonExp {
  /** is the left argument an ancestor of right (or equal)? */
  readonly _ancestor?: InputMaybe<Scalars["ltree"]["input"]>;
  /** does array contain an ancestor of `ltree`? */
  readonly _ancestor_any?: InputMaybe<ReadonlyArray<Scalars["ltree"]["input"]>>;
  /** is the left argument a descendant of right (or equal)? */
  readonly _descendant?: InputMaybe<Scalars["ltree"]["input"]>;
  /** does array contain a descendant of `ltree`? */
  readonly _descendant_any?: InputMaybe<
    ReadonlyArray<Scalars["ltree"]["input"]>
  >;
  readonly _eq?: InputMaybe<Scalars["ltree"]["input"]>;
  readonly _gt?: InputMaybe<Scalars["ltree"]["input"]>;
  readonly _gte?: InputMaybe<Scalars["ltree"]["input"]>;
  readonly _in?: InputMaybe<ReadonlyArray<Scalars["ltree"]["input"]>>;
  readonly _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly _lt?: InputMaybe<Scalars["ltree"]["input"]>;
  readonly _lte?: InputMaybe<Scalars["ltree"]["input"]>;
  /** does `ltree` match `lquery`? */
  readonly _matches?: InputMaybe<Scalars["lquery"]["input"]>;
  /** does `ltree` match any `lquery` in array? */
  readonly _matches_any?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
  /** does `ltree` match `ltxtquery`? */
  readonly _matches_fulltext?: InputMaybe<Scalars["ltxtquery"]["input"]>;
  readonly _neq?: InputMaybe<Scalars["ltree"]["input"]>;
  readonly _nin?: InputMaybe<ReadonlyArray<Scalars["ltree"]["input"]>>;
}

export interface MatchResearchArgs {
  readonly match_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly match_threshold?: InputMaybe<Scalars["float8"]["input"]>;
  readonly query_embedding?: InputMaybe<Scalars["vector"]["input"]>;
}

/** columns and relationships of "metric_definitions" */
export interface MetricDefinitions {
  readonly category?: Maybe<Scalars["String"]["output"]>;
  /** An array relationship */
  readonly company_metrics: ReadonlyArray<CompanyMetrics>;
  /** An aggregate relationship */
  readonly company_metrics_aggregate: CompanyMetricsAggregate;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly id: Scalars["Int"]["output"];
  readonly is_dimensional?: Maybe<Scalars["Boolean"]["output"]>;
  readonly name: Scalars["String"]["output"];
  /** An array relationship */
  readonly spider_metrics: ReadonlyArray<SpiderMetrics>;
  /** An aggregate relationship */
  readonly spider_metrics_aggregate: SpiderMetricsAggregate;
  readonly type: Scalars["String"]["output"];
  readonly unit?: Maybe<Scalars["String"]["output"]>;
}

/** columns and relationships of "metric_definitions" */
export type MetricDefinitionsCompanyMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyMetricsOrderBy>>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
};

/** columns and relationships of "metric_definitions" */
export type MetricDefinitionsCompanyMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyMetricsOrderBy>>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
};

/** columns and relationships of "metric_definitions" */
export type MetricDefinitionsSpiderMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SpiderMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SpiderMetricsOrderBy>>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
};

/** columns and relationships of "metric_definitions" */
export type MetricDefinitionsSpiderMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SpiderMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SpiderMetricsOrderBy>>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
};

/** aggregated selection of "metric_definitions" */
export interface MetricDefinitionsAggregate {
  readonly aggregate?: Maybe<MetricDefinitionsAggregateFields>;
  readonly nodes: ReadonlyArray<MetricDefinitions>;
}

/** aggregate fields of "metric_definitions" */
export interface MetricDefinitionsAggregateFields {
  readonly avg?: Maybe<MetricDefinitionsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<MetricDefinitionsMaxFields>;
  readonly min?: Maybe<MetricDefinitionsMinFields>;
  readonly stddev?: Maybe<MetricDefinitionsStddevFields>;
  readonly stddev_pop?: Maybe<MetricDefinitionsStddevPopFields>;
  readonly stddev_samp?: Maybe<MetricDefinitionsStddevSampFields>;
  readonly sum?: Maybe<MetricDefinitionsSumFields>;
  readonly var_pop?: Maybe<MetricDefinitionsVarPopFields>;
  readonly var_samp?: Maybe<MetricDefinitionsVarSampFields>;
  readonly variance?: Maybe<MetricDefinitionsVarianceFields>;
}

/** aggregate fields of "metric_definitions" */
export type MetricDefinitionsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<MetricDefinitionsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface MetricDefinitionsAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "metric_definitions". All fields are combined with a logical 'AND'. */
export interface MetricDefinitionsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<MetricDefinitionsBoolExp>>;
  readonly _not?: InputMaybe<MetricDefinitionsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<MetricDefinitionsBoolExp>>;
  readonly category?: InputMaybe<StringComparisonExp>;
  readonly company_metrics?: InputMaybe<CompanyMetricsBoolExp>;
  readonly company_metrics_aggregate?: InputMaybe<CompanyMetricsAggregateBoolExp>;
  readonly description?: InputMaybe<StringComparisonExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly is_dimensional?: InputMaybe<BooleanComparisonExp>;
  readonly name?: InputMaybe<StringComparisonExp>;
  readonly spider_metrics?: InputMaybe<SpiderMetricsBoolExp>;
  readonly spider_metrics_aggregate?: InputMaybe<SpiderMetricsAggregateBoolExp>;
  readonly type?: InputMaybe<StringComparisonExp>;
  readonly unit?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "metric_definitions" */
export type MetricDefinitionsConstraint =
  /** unique or primary key constraint on columns "category", "name" */
  | "metric_definitions_name_category_key"
  /** unique or primary key constraint on columns "id" */
  | "metric_definitions_pkey";

/** input type for incrementing numeric columns in table "metric_definitions" */
export interface MetricDefinitionsIncInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "metric_definitions" */
export interface MetricDefinitionsInsertInput {
  readonly category?: InputMaybe<Scalars["String"]["input"]>;
  readonly company_metrics?: InputMaybe<CompanyMetricsArrRelInsertInput>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly is_dimensional?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly spider_metrics?: InputMaybe<SpiderMetricsArrRelInsertInput>;
  readonly type?: InputMaybe<Scalars["String"]["input"]>;
  readonly unit?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate max on columns */
export interface MetricDefinitionsMaxFields {
  readonly category?: Maybe<Scalars["String"]["output"]>;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly type?: Maybe<Scalars["String"]["output"]>;
  readonly unit?: Maybe<Scalars["String"]["output"]>;
}

/** aggregate min on columns */
export interface MetricDefinitionsMinFields {
  readonly category?: Maybe<Scalars["String"]["output"]>;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly type?: Maybe<Scalars["String"]["output"]>;
  readonly unit?: Maybe<Scalars["String"]["output"]>;
}

/** response of any mutation on the table "metric_definitions" */
export interface MetricDefinitionsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<MetricDefinitions>;
}

/** input type for inserting object relation for remote table "metric_definitions" */
export interface MetricDefinitionsObjRelInsertInput {
  readonly data: MetricDefinitionsInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<MetricDefinitionsOnConflict>;
}

/** on_conflict condition type for table "metric_definitions" */
export interface MetricDefinitionsOnConflict {
  readonly constraint: MetricDefinitionsConstraint;
  readonly update_columns: ReadonlyArray<MetricDefinitionsUpdateColumn>;
  readonly where?: InputMaybe<MetricDefinitionsBoolExp>;
}

/** Ordering options when selecting data from "metric_definitions". */
export interface MetricDefinitionsOrderBy {
  readonly category?: InputMaybe<OrderBy>;
  readonly company_metrics_aggregate?: InputMaybe<CompanyMetricsAggregateOrderBy>;
  readonly description?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly is_dimensional?: InputMaybe<OrderBy>;
  readonly name?: InputMaybe<OrderBy>;
  readonly spider_metrics_aggregate?: InputMaybe<SpiderMetricsAggregateOrderBy>;
  readonly type?: InputMaybe<OrderBy>;
  readonly unit?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: metric_definitions */
export interface MetricDefinitionsPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** select columns of table "metric_definitions" */
export type MetricDefinitionsSelectColumn =
  /** column name */
  | "category"
  /** column name */
  | "description"
  /** column name */
  | "id"
  /** column name */
  | "is_dimensional"
  /** column name */
  | "name"
  /** column name */
  | "type"
  /** column name */
  | "unit";

/** input type for updating data in table "metric_definitions" */
export interface MetricDefinitionsSetInput {
  readonly category?: InputMaybe<Scalars["String"]["input"]>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly is_dimensional?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly type?: InputMaybe<Scalars["String"]["input"]>;
  readonly unit?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate stddev on columns */
export interface MetricDefinitionsStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface MetricDefinitionsStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface MetricDefinitionsStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "metric_definitions" */
export interface MetricDefinitionsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: MetricDefinitionsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface MetricDefinitionsStreamCursorValueInput {
  readonly category?: InputMaybe<Scalars["String"]["input"]>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly is_dimensional?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly type?: InputMaybe<Scalars["String"]["input"]>;
  readonly unit?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface MetricDefinitionsSumFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "metric_definitions" */
export type MetricDefinitionsUpdateColumn =
  /** column name */
  | "category"
  /** column name */
  | "description"
  /** column name */
  | "id"
  /** column name */
  | "is_dimensional"
  /** column name */
  | "name"
  /** column name */
  | "type"
  /** column name */
  | "unit";

export interface MetricDefinitionsUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<MetricDefinitionsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<MetricDefinitionsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: MetricDefinitionsBoolExp;
}

/** aggregate var_pop on columns */
export interface MetricDefinitionsVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface MetricDefinitionsVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface MetricDefinitionsVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** mutation root */
export interface MutationRoot {
  /** delete data from the table: "ad_daily_metrics" */
  readonly delete_ad_daily_metrics?: Maybe<AdDailyMetricsMutationResponse>;
  /** delete single row from the table: "ad_daily_metrics" */
  readonly delete_ad_daily_metrics_by_pk?: Maybe<AdDailyMetrics>;
  /** delete data from the table: "ad_packages" */
  readonly delete_ad_packages?: Maybe<AdPackagesMutationResponse>;
  /** delete single row from the table: "ad_packages" */
  readonly delete_ad_packages_by_pk?: Maybe<AdPackages>;
  /** delete data from the table: "ad_variants" */
  readonly delete_ad_variants?: Maybe<AdVariantsMutationResponse>;
  /** delete single row from the table: "ad_variants" */
  readonly delete_ad_variants_by_pk?: Maybe<AdVariants>;
  /** delete data from the table: "addresses" */
  readonly delete_addresses?: Maybe<AddressesMutationResponse>;
  /** delete single row from the table: "addresses" */
  readonly delete_addresses_by_pk?: Maybe<Addresses>;
  /** delete data from the table: "ads" */
  readonly delete_ads?: Maybe<AdsMutationResponse>;
  /** delete single row from the table: "ads" */
  readonly delete_ads_by_pk?: Maybe<Ads>;
  /** delete data from the table: "blacklisted_domains" */
  readonly delete_blacklisted_domains?: Maybe<BlacklistedDomainsMutationResponse>;
  /** delete single row from the table: "blacklisted_domains" */
  readonly delete_blacklisted_domains_by_pk?: Maybe<BlacklistedDomains>;
  /** delete data from the table: "blacklisted_urls" */
  readonly delete_blacklisted_urls?: Maybe<BlacklistedUrlsMutationResponse>;
  /** delete single row from the table: "blacklisted_urls" */
  readonly delete_blacklisted_urls_by_pk?: Maybe<BlacklistedUrls>;
  /** delete data from the table: "blocked_ips" */
  readonly delete_blocked_ips?: Maybe<BlockedIpsMutationResponse>;
  /** delete single row from the table: "blocked_ips" */
  readonly delete_blocked_ips_by_pk?: Maybe<BlockedIps>;
  /** delete data from the table: "bookmark_folders" */
  readonly delete_bookmark_folders?: Maybe<BookmarkFoldersMutationResponse>;
  /** delete single row from the table: "bookmark_folders" */
  readonly delete_bookmark_folders_by_pk?: Maybe<BookmarkFolders>;
  /** delete data from the table: "bookmarks" */
  readonly delete_bookmarks?: Maybe<BookmarksMutationResponse>;
  /** delete single row from the table: "bookmarks" */
  readonly delete_bookmarks_by_pk?: Maybe<Bookmarks>;
  /** delete data from the table: "business_domains" */
  readonly delete_business_domains?: Maybe<BusinessDomainsMutationResponse>;
  /** delete single row from the table: "business_domains" */
  readonly delete_business_domains_by_pk?: Maybe<BusinessDomains>;
  /** delete data from the table: "categories" */
  readonly delete_categories?: Maybe<CategoriesMutationResponse>;
  /** delete single row from the table: "categories" */
  readonly delete_categories_by_pk?: Maybe<Categories>;
  /** delete data from the table: "categorized_urls" */
  readonly delete_categorized_urls?: Maybe<CategorizedUrlsMutationResponse>;
  /** delete single row from the table: "categorized_urls" */
  readonly delete_categorized_urls_by_pk?: Maybe<CategorizedUrls>;
  /** delete data from the table: "circuit_breaker_states" */
  readonly delete_circuit_breaker_states?: Maybe<CircuitBreakerStatesMutationResponse>;
  /** delete single row from the table: "circuit_breaker_states" */
  readonly delete_circuit_breaker_states_by_pk?: Maybe<CircuitBreakerStates>;
  /** delete data from the table: "cities" */
  readonly delete_cities?: Maybe<CitiesMutationResponse>;
  /** delete single row from the table: "cities" */
  readonly delete_cities_by_pk?: Maybe<Cities>;
  /** delete data from the table: "comments" */
  readonly delete_comments?: Maybe<CommentsMutationResponse>;
  /** delete single row from the table: "comments" */
  readonly delete_comments_by_pk?: Maybe<Comments>;
  /** delete data from the table: "companies" */
  readonly delete_companies?: Maybe<CompaniesMutationResponse>;
  /** delete single row from the table: "companies" */
  readonly delete_companies_by_pk?: Maybe<Companies>;
  /** delete data from the table: "company_contacts" */
  readonly delete_company_contacts?: Maybe<CompanyContactsMutationResponse>;
  /** delete single row from the table: "company_contacts" */
  readonly delete_company_contacts_by_pk?: Maybe<CompanyContacts>;
  /** delete data from the table: "company_employees" */
  readonly delete_company_employees?: Maybe<CompanyEmployeesMutationResponse>;
  /** delete single row from the table: "company_employees" */
  readonly delete_company_employees_by_pk?: Maybe<CompanyEmployees>;
  /** delete data from the table: "company_extras" */
  readonly delete_company_extras?: Maybe<CompanyExtrasMutationResponse>;
  /** delete single row from the table: "company_extras" */
  readonly delete_company_extras_by_pk?: Maybe<CompanyExtras>;
  /** delete data from the table: "company_metrics" */
  readonly delete_company_metrics?: Maybe<CompanyMetricsMutationResponse>;
  /** delete single row from the table: "company_metrics" */
  readonly delete_company_metrics_by_pk?: Maybe<CompanyMetrics>;
  /** delete data from the table: "contacts" */
  readonly delete_contacts?: Maybe<ContactsMutationResponse>;
  /** delete single row from the table: "contacts" */
  readonly delete_contacts_by_pk?: Maybe<Contacts>;
  /** delete data from the table: "content_categories" */
  readonly delete_content_categories?: Maybe<ContentCategoriesMutationResponse>;
  /** delete single row from the table: "content_categories" */
  readonly delete_content_categories_by_pk?: Maybe<ContentCategories>;
  /** delete data from the table: "content_source_visits" */
  readonly delete_content_source_visits?: Maybe<ContentSourceVisitsMutationResponse>;
  /** delete single row from the table: "content_source_visits" */
  readonly delete_content_source_visits_by_pk?: Maybe<ContentSourceVisits>;
  /** delete data from the table: "content_sources" */
  readonly delete_content_sources?: Maybe<ContentSourcesMutationResponse>;
  /** delete single row from the table: "content_sources" */
  readonly delete_content_sources_by_pk?: Maybe<ContentSources>;
  /** delete data from the table: "content_statuses" */
  readonly delete_content_statuses?: Maybe<ContentStatusesMutationResponse>;
  /** delete single row from the table: "content_statuses" */
  readonly delete_content_statuses_by_pk?: Maybe<ContentStatuses>;
  /** delete data from the table: "content_tags" */
  readonly delete_content_tags?: Maybe<ContentTagsMutationResponse>;
  /** delete single row from the table: "content_tags" */
  readonly delete_content_tags_by_pk?: Maybe<ContentTags>;
  /** delete data from the table: "contents" */
  readonly delete_contents?: Maybe<ContentsMutationResponse>;
  /** delete single row from the table: "contents" */
  readonly delete_contents_by_pk?: Maybe<Contents>;
  /** delete data from the table: "countries" */
  readonly delete_countries?: Maybe<CountriesMutationResponse>;
  /** delete single row from the table: "countries" */
  readonly delete_countries_by_pk?: Maybe<Countries>;
  /** delete data from the table: "customer_payments" */
  readonly delete_customer_payments?: Maybe<CustomerPaymentsMutationResponse>;
  /** delete single row from the table: "customer_payments" */
  readonly delete_customer_payments_by_pk?: Maybe<CustomerPayments>;
  /** delete data from the table: "customer_processed_webhooks" */
  readonly delete_customer_processed_webhooks?: Maybe<CustomerProcessedWebhooksMutationResponse>;
  /** delete single row from the table: "customer_processed_webhooks" */
  readonly delete_customer_processed_webhooks_by_pk?: Maybe<CustomerProcessedWebhooks>;
  /** delete data from the table: "customer_refunds" */
  readonly delete_customer_refunds?: Maybe<CustomerRefundsMutationResponse>;
  /** delete single row from the table: "customer_refunds" */
  readonly delete_customer_refunds_by_pk?: Maybe<CustomerRefunds>;
  /** delete data from the table: "customer_subscription_plans" */
  readonly delete_customer_subscription_plans?: Maybe<CustomerSubscriptionPlansMutationResponse>;
  /** delete single row from the table: "customer_subscription_plans" */
  readonly delete_customer_subscription_plans_by_pk?: Maybe<CustomerSubscriptionPlans>;
  /** delete data from the table: "customer_subscriptions" */
  readonly delete_customer_subscriptions?: Maybe<CustomerSubscriptionsMutationResponse>;
  /** delete single row from the table: "customer_subscriptions" */
  readonly delete_customer_subscriptions_by_pk?: Maybe<CustomerSubscriptions>;
  /** delete data from the table: "embedding_reviews" */
  readonly delete_embedding_reviews?: Maybe<EmbeddingReviewsMutationResponse>;
  /** delete single row from the table: "embedding_reviews" */
  readonly delete_embedding_reviews_by_pk?: Maybe<EmbeddingReviews>;
  /** delete data from the table: "error_logs" */
  readonly delete_error_logs?: Maybe<ErrorLogsMutationResponse>;
  /** delete single row from the table: "error_logs" */
  readonly delete_error_logs_by_pk?: Maybe<ErrorLogs>;
  /** delete data from the table: "feature_requests" */
  readonly delete_feature_requests?: Maybe<FeatureRequestsMutationResponse>;
  /** delete single row from the table: "feature_requests" */
  readonly delete_feature_requests_by_pk?: Maybe<FeatureRequests>;
  /** delete data from the table: "feature_votes" */
  readonly delete_feature_votes?: Maybe<FeatureVotesMutationResponse>;
  /** delete single row from the table: "feature_votes" */
  readonly delete_feature_votes_by_pk?: Maybe<FeatureVotes>;
  /** delete data from the table: "feed_categories" */
  readonly delete_feed_categories?: Maybe<FeedCategoriesMutationResponse>;
  /** delete single row from the table: "feed_categories" */
  readonly delete_feed_categories_by_pk?: Maybe<FeedCategories>;
  /** delete data from the table: "feed_sources" */
  readonly delete_feed_sources?: Maybe<FeedSourcesMutationResponse>;
  /** delete single row from the table: "feed_sources" */
  readonly delete_feed_sources_by_pk?: Maybe<FeedSources>;
  /** delete data from the table: "feedbacks" */
  readonly delete_feedbacks?: Maybe<FeedbacksMutationResponse>;
  /** delete single row from the table: "feedbacks" */
  readonly delete_feedbacks_by_pk?: Maybe<Feedbacks>;
  /** delete data from the table: "feeds" */
  readonly delete_feeds?: Maybe<FeedsMutationResponse>;
  /** delete single row from the table: "feeds" */
  readonly delete_feeds_by_pk?: Maybe<Feeds>;
  /** delete data from the table: "follows" */
  readonly delete_follows?: Maybe<FollowsMutationResponse>;
  /** delete single row from the table: "follows" */
  readonly delete_follows_by_pk?: Maybe<Follows>;
  /** delete data from the table: "metric_definitions" */
  readonly delete_metric_definitions?: Maybe<MetricDefinitionsMutationResponse>;
  /** delete single row from the table: "metric_definitions" */
  readonly delete_metric_definitions_by_pk?: Maybe<MetricDefinitions>;
  /** delete data from the table: "news" */
  readonly delete_news?: Maybe<NewsMutationResponse>;
  /** delete single row from the table: "news" */
  readonly delete_news_by_pk?: Maybe<News>;
  /** delete data from the table: "news_summaries" */
  readonly delete_news_summaries?: Maybe<NewsSummariesMutationResponse>;
  /** delete single row from the table: "news_summaries" */
  readonly delete_news_summaries_by_pk?: Maybe<NewsSummaries>;
  /** delete data from the table: "news_tags" */
  readonly delete_news_tags?: Maybe<NewsTagsMutationResponse>;
  /** delete single row from the table: "news_tags" */
  readonly delete_news_tags_by_pk?: Maybe<NewsTags>;
  /** delete data from the table: "newsletters" */
  readonly delete_newsletters?: Maybe<NewslettersMutationResponse>;
  /** delete single row from the table: "newsletters" */
  readonly delete_newsletters_by_pk?: Maybe<Newsletters>;
  /** delete data from the table: "payment_providers" */
  readonly delete_payment_providers?: Maybe<PaymentProvidersMutationResponse>;
  /** delete single row from the table: "payment_providers" */
  readonly delete_payment_providers_by_pk?: Maybe<PaymentProviders>;
  /** delete data from the table: "plan_permissions" */
  readonly delete_plan_permissions?: Maybe<PlanPermissionsMutationResponse>;
  /** delete single row from the table: "plan_permissions" */
  readonly delete_plan_permissions_by_pk?: Maybe<PlanPermissions>;
  /** delete data from the table: "recent_errors" */
  readonly delete_recent_errors?: Maybe<RecentErrorsMutationResponse>;
  /** delete data from the table: "referrals" */
  readonly delete_referrals?: Maybe<ReferralsMutationResponse>;
  /** delete single row from the table: "referrals" */
  readonly delete_referrals_by_pk?: Maybe<Referrals>;
  /** delete data from the table: "referrer_blocks" */
  readonly delete_referrer_blocks?: Maybe<ReferrerBlocksMutationResponse>;
  /** delete single row from the table: "referrer_blocks" */
  readonly delete_referrer_blocks_by_pk?: Maybe<ReferrerBlocks>;
  /** delete data from the table: "research" */
  readonly delete_research?: Maybe<ResearchMutationResponse>;
  /** delete single row from the table: "research" */
  readonly delete_research_by_pk?: Maybe<Research>;
  /** delete data from the table: "research_embeddings" */
  readonly delete_research_embeddings?: Maybe<ResearchEmbeddingsMutationResponse>;
  /** delete single row from the table: "research_embeddings" */
  readonly delete_research_embeddings_by_pk?: Maybe<ResearchEmbeddings>;
  /** delete data from the table: "responses" */
  readonly delete_responses?: Maybe<ResponsesMutationResponse>;
  /** delete single row from the table: "responses" */
  readonly delete_responses_by_pk?: Maybe<Responses>;
  /** delete data from the table: "role_hierarchy" */
  readonly delete_role_hierarchy?: Maybe<RoleHierarchyMutationResponse>;
  /** delete single row from the table: "role_hierarchy" */
  readonly delete_role_hierarchy_by_pk?: Maybe<RoleHierarchy>;
  /** delete data from the table: "role_permissions" */
  readonly delete_role_permissions?: Maybe<RolePermissionsMutationResponse>;
  /** delete single row from the table: "role_permissions" */
  readonly delete_role_permissions_by_pk?: Maybe<RolePermissions>;
  /** delete data from the table: "role_permissions_materialized" */
  readonly delete_role_permissions_materialized?: Maybe<RolePermissionsMaterializedMutationResponse>;
  /** delete single row from the table: "role_permissions_materialized" */
  readonly delete_role_permissions_materialized_by_pk?: Maybe<RolePermissionsMaterialized>;
  /** delete data from the table: "scoring_weights" */
  readonly delete_scoring_weights?: Maybe<ScoringWeightsMutationResponse>;
  /** delete single row from the table: "scoring_weights" */
  readonly delete_scoring_weights_by_pk?: Maybe<ScoringWeights>;
  /** delete data from the table: "searches" */
  readonly delete_searches?: Maybe<SearchesMutationResponse>;
  /** delete single row from the table: "searches" */
  readonly delete_searches_by_pk?: Maybe<Searches>;
  /** delete data from the table: "social_media" */
  readonly delete_social_media?: Maybe<SocialMediaMutationResponse>;
  /** delete single row from the table: "social_media" */
  readonly delete_social_media_by_pk?: Maybe<SocialMedia>;
  /** delete data from the table: "spider_metrics" */
  readonly delete_spider_metrics?: Maybe<SpiderMetricsMutationResponse>;
  /** delete single row from the table: "spider_metrics" */
  readonly delete_spider_metrics_by_pk?: Maybe<SpiderMetrics>;
  /** delete data from the table: "strapi_migrations" */
  readonly delete_strapi_migrations?: Maybe<StrapiMigrationsMutationResponse>;
  /** delete single row from the table: "strapi_migrations" */
  readonly delete_strapi_migrations_by_pk?: Maybe<StrapiMigrations>;
  /** delete data from the table: "strapi_migrations_internal" */
  readonly delete_strapi_migrations_internal?: Maybe<StrapiMigrationsInternalMutationResponse>;
  /** delete single row from the table: "strapi_migrations_internal" */
  readonly delete_strapi_migrations_internal_by_pk?: Maybe<StrapiMigrationsInternal>;
  /** delete data from the table: "table_maintenance_log" */
  readonly delete_table_maintenance_log?: Maybe<TableMaintenanceLogMutationResponse>;
  /** delete single row from the table: "table_maintenance_log" */
  readonly delete_table_maintenance_log_by_pk?: Maybe<TableMaintenanceLog>;
  /** delete data from the table: "table_query_performance" */
  readonly delete_table_query_performance?: Maybe<TableQueryPerformanceMutationResponse>;
  /** delete data from the table: "table_sequence_usage" */
  readonly delete_table_sequence_usage?: Maybe<TableSequenceUsageMutationResponse>;
  /** delete data from the table: "table_statistics" */
  readonly delete_table_statistics?: Maybe<TableStatisticsMutationResponse>;
  /** delete single row from the table: "table_statistics" */
  readonly delete_table_statistics_by_pk?: Maybe<TableStatistics>;
  /** delete data from the table: "tags" */
  readonly delete_tags?: Maybe<TagsMutationResponse>;
  /** delete single row from the table: "tags" */
  readonly delete_tags_by_pk?: Maybe<Tags>;
  /** delete data from the table: "user_metrics" */
  readonly delete_user_metrics?: Maybe<UserMetricsMutationResponse>;
  /** delete single row from the table: "user_metrics" */
  readonly delete_user_metrics_by_pk?: Maybe<UserMetrics>;
  /** delete data from the table: "user_profiles" */
  readonly delete_user_profiles?: Maybe<UserProfilesMutationResponse>;
  /** delete single row from the table: "user_profiles" */
  readonly delete_user_profiles_by_pk?: Maybe<UserProfiles>;
  /** delete data from the table: "votes" */
  readonly delete_votes?: Maybe<VotesMutationResponse>;
  /** delete single row from the table: "votes" */
  readonly delete_votes_by_pk?: Maybe<Votes>;
  /** delete data from the table: "workflows" */
  readonly delete_workflows?: Maybe<WorkflowsMutationResponse>;
  /** delete single row from the table: "workflows" */
  readonly delete_workflows_by_pk?: Maybe<Workflows>;
  /** insert data into the table: "ad_daily_metrics" */
  readonly insert_ad_daily_metrics?: Maybe<AdDailyMetricsMutationResponse>;
  /** insert a single row into the table: "ad_daily_metrics" */
  readonly insert_ad_daily_metrics_one?: Maybe<AdDailyMetrics>;
  /** insert data into the table: "ad_packages" */
  readonly insert_ad_packages?: Maybe<AdPackagesMutationResponse>;
  /** insert a single row into the table: "ad_packages" */
  readonly insert_ad_packages_one?: Maybe<AdPackages>;
  /** insert data into the table: "ad_variants" */
  readonly insert_ad_variants?: Maybe<AdVariantsMutationResponse>;
  /** insert a single row into the table: "ad_variants" */
  readonly insert_ad_variants_one?: Maybe<AdVariants>;
  /** insert data into the table: "addresses" */
  readonly insert_addresses?: Maybe<AddressesMutationResponse>;
  /** insert a single row into the table: "addresses" */
  readonly insert_addresses_one?: Maybe<Addresses>;
  /** insert data into the table: "ads" */
  readonly insert_ads?: Maybe<AdsMutationResponse>;
  /** insert a single row into the table: "ads" */
  readonly insert_ads_one?: Maybe<Ads>;
  /** insert data into the table: "blacklisted_domains" */
  readonly insert_blacklisted_domains?: Maybe<BlacklistedDomainsMutationResponse>;
  /** insert a single row into the table: "blacklisted_domains" */
  readonly insert_blacklisted_domains_one?: Maybe<BlacklistedDomains>;
  /** insert data into the table: "blacklisted_urls" */
  readonly insert_blacklisted_urls?: Maybe<BlacklistedUrlsMutationResponse>;
  /** insert a single row into the table: "blacklisted_urls" */
  readonly insert_blacklisted_urls_one?: Maybe<BlacklistedUrls>;
  /** insert data into the table: "blocked_ips" */
  readonly insert_blocked_ips?: Maybe<BlockedIpsMutationResponse>;
  /** insert a single row into the table: "blocked_ips" */
  readonly insert_blocked_ips_one?: Maybe<BlockedIps>;
  /** insert data into the table: "bookmark_folders" */
  readonly insert_bookmark_folders?: Maybe<BookmarkFoldersMutationResponse>;
  /** insert a single row into the table: "bookmark_folders" */
  readonly insert_bookmark_folders_one?: Maybe<BookmarkFolders>;
  /** insert data into the table: "bookmarks" */
  readonly insert_bookmarks?: Maybe<BookmarksMutationResponse>;
  /** insert a single row into the table: "bookmarks" */
  readonly insert_bookmarks_one?: Maybe<Bookmarks>;
  /** insert data into the table: "business_domains" */
  readonly insert_business_domains?: Maybe<BusinessDomainsMutationResponse>;
  /** insert a single row into the table: "business_domains" */
  readonly insert_business_domains_one?: Maybe<BusinessDomains>;
  /** insert data into the table: "categories" */
  readonly insert_categories?: Maybe<CategoriesMutationResponse>;
  /** insert a single row into the table: "categories" */
  readonly insert_categories_one?: Maybe<Categories>;
  /** insert data into the table: "categorized_urls" */
  readonly insert_categorized_urls?: Maybe<CategorizedUrlsMutationResponse>;
  /** insert a single row into the table: "categorized_urls" */
  readonly insert_categorized_urls_one?: Maybe<CategorizedUrls>;
  /** insert data into the table: "circuit_breaker_states" */
  readonly insert_circuit_breaker_states?: Maybe<CircuitBreakerStatesMutationResponse>;
  /** insert a single row into the table: "circuit_breaker_states" */
  readonly insert_circuit_breaker_states_one?: Maybe<CircuitBreakerStates>;
  /** insert data into the table: "cities" */
  readonly insert_cities?: Maybe<CitiesMutationResponse>;
  /** insert a single row into the table: "cities" */
  readonly insert_cities_one?: Maybe<Cities>;
  /** insert data into the table: "comments" */
  readonly insert_comments?: Maybe<CommentsMutationResponse>;
  /** insert a single row into the table: "comments" */
  readonly insert_comments_one?: Maybe<Comments>;
  /** insert data into the table: "companies" */
  readonly insert_companies?: Maybe<CompaniesMutationResponse>;
  /** insert a single row into the table: "companies" */
  readonly insert_companies_one?: Maybe<Companies>;
  /** insert data into the table: "company_contacts" */
  readonly insert_company_contacts?: Maybe<CompanyContactsMutationResponse>;
  /** insert a single row into the table: "company_contacts" */
  readonly insert_company_contacts_one?: Maybe<CompanyContacts>;
  /** insert data into the table: "company_employees" */
  readonly insert_company_employees?: Maybe<CompanyEmployeesMutationResponse>;
  /** insert a single row into the table: "company_employees" */
  readonly insert_company_employees_one?: Maybe<CompanyEmployees>;
  /** insert data into the table: "company_extras" */
  readonly insert_company_extras?: Maybe<CompanyExtrasMutationResponse>;
  /** insert a single row into the table: "company_extras" */
  readonly insert_company_extras_one?: Maybe<CompanyExtras>;
  /** insert data into the table: "company_metrics" */
  readonly insert_company_metrics?: Maybe<CompanyMetricsMutationResponse>;
  /** insert a single row into the table: "company_metrics" */
  readonly insert_company_metrics_one?: Maybe<CompanyMetrics>;
  /** insert data into the table: "contacts" */
  readonly insert_contacts?: Maybe<ContactsMutationResponse>;
  /** insert a single row into the table: "contacts" */
  readonly insert_contacts_one?: Maybe<Contacts>;
  /** insert data into the table: "content_categories" */
  readonly insert_content_categories?: Maybe<ContentCategoriesMutationResponse>;
  /** insert a single row into the table: "content_categories" */
  readonly insert_content_categories_one?: Maybe<ContentCategories>;
  /** insert data into the table: "content_source_visits" */
  readonly insert_content_source_visits?: Maybe<ContentSourceVisitsMutationResponse>;
  /** insert a single row into the table: "content_source_visits" */
  readonly insert_content_source_visits_one?: Maybe<ContentSourceVisits>;
  /** insert data into the table: "content_sources" */
  readonly insert_content_sources?: Maybe<ContentSourcesMutationResponse>;
  /** insert a single row into the table: "content_sources" */
  readonly insert_content_sources_one?: Maybe<ContentSources>;
  /** insert data into the table: "content_statuses" */
  readonly insert_content_statuses?: Maybe<ContentStatusesMutationResponse>;
  /** insert a single row into the table: "content_statuses" */
  readonly insert_content_statuses_one?: Maybe<ContentStatuses>;
  /** insert data into the table: "content_tags" */
  readonly insert_content_tags?: Maybe<ContentTagsMutationResponse>;
  /** insert a single row into the table: "content_tags" */
  readonly insert_content_tags_one?: Maybe<ContentTags>;
  /** insert data into the table: "contents" */
  readonly insert_contents?: Maybe<ContentsMutationResponse>;
  /** insert a single row into the table: "contents" */
  readonly insert_contents_one?: Maybe<Contents>;
  /** insert data into the table: "countries" */
  readonly insert_countries?: Maybe<CountriesMutationResponse>;
  /** insert a single row into the table: "countries" */
  readonly insert_countries_one?: Maybe<Countries>;
  /** insert data into the table: "customer_payments" */
  readonly insert_customer_payments?: Maybe<CustomerPaymentsMutationResponse>;
  /** insert a single row into the table: "customer_payments" */
  readonly insert_customer_payments_one?: Maybe<CustomerPayments>;
  /** insert data into the table: "customer_processed_webhooks" */
  readonly insert_customer_processed_webhooks?: Maybe<CustomerProcessedWebhooksMutationResponse>;
  /** insert a single row into the table: "customer_processed_webhooks" */
  readonly insert_customer_processed_webhooks_one?: Maybe<CustomerProcessedWebhooks>;
  /** insert data into the table: "customer_refunds" */
  readonly insert_customer_refunds?: Maybe<CustomerRefundsMutationResponse>;
  /** insert a single row into the table: "customer_refunds" */
  readonly insert_customer_refunds_one?: Maybe<CustomerRefunds>;
  /** insert data into the table: "customer_subscription_plans" */
  readonly insert_customer_subscription_plans?: Maybe<CustomerSubscriptionPlansMutationResponse>;
  /** insert a single row into the table: "customer_subscription_plans" */
  readonly insert_customer_subscription_plans_one?: Maybe<CustomerSubscriptionPlans>;
  /** insert data into the table: "customer_subscriptions" */
  readonly insert_customer_subscriptions?: Maybe<CustomerSubscriptionsMutationResponse>;
  /** insert a single row into the table: "customer_subscriptions" */
  readonly insert_customer_subscriptions_one?: Maybe<CustomerSubscriptions>;
  /** insert data into the table: "embedding_reviews" */
  readonly insert_embedding_reviews?: Maybe<EmbeddingReviewsMutationResponse>;
  /** insert a single row into the table: "embedding_reviews" */
  readonly insert_embedding_reviews_one?: Maybe<EmbeddingReviews>;
  /** insert data into the table: "error_logs" */
  readonly insert_error_logs?: Maybe<ErrorLogsMutationResponse>;
  /** insert a single row into the table: "error_logs" */
  readonly insert_error_logs_one?: Maybe<ErrorLogs>;
  /** insert data into the table: "feature_requests" */
  readonly insert_feature_requests?: Maybe<FeatureRequestsMutationResponse>;
  /** insert a single row into the table: "feature_requests" */
  readonly insert_feature_requests_one?: Maybe<FeatureRequests>;
  /** insert data into the table: "feature_votes" */
  readonly insert_feature_votes?: Maybe<FeatureVotesMutationResponse>;
  /** insert a single row into the table: "feature_votes" */
  readonly insert_feature_votes_one?: Maybe<FeatureVotes>;
  /** insert data into the table: "feed_categories" */
  readonly insert_feed_categories?: Maybe<FeedCategoriesMutationResponse>;
  /** insert a single row into the table: "feed_categories" */
  readonly insert_feed_categories_one?: Maybe<FeedCategories>;
  /** insert data into the table: "feed_sources" */
  readonly insert_feed_sources?: Maybe<FeedSourcesMutationResponse>;
  /** insert a single row into the table: "feed_sources" */
  readonly insert_feed_sources_one?: Maybe<FeedSources>;
  /** insert data into the table: "feedbacks" */
  readonly insert_feedbacks?: Maybe<FeedbacksMutationResponse>;
  /** insert a single row into the table: "feedbacks" */
  readonly insert_feedbacks_one?: Maybe<Feedbacks>;
  /** insert data into the table: "feeds" */
  readonly insert_feeds?: Maybe<FeedsMutationResponse>;
  /** insert a single row into the table: "feeds" */
  readonly insert_feeds_one?: Maybe<Feeds>;
  /** insert data into the table: "follows" */
  readonly insert_follows?: Maybe<FollowsMutationResponse>;
  /** insert a single row into the table: "follows" */
  readonly insert_follows_one?: Maybe<Follows>;
  /** insert data into the table: "metric_definitions" */
  readonly insert_metric_definitions?: Maybe<MetricDefinitionsMutationResponse>;
  /** insert a single row into the table: "metric_definitions" */
  readonly insert_metric_definitions_one?: Maybe<MetricDefinitions>;
  /** insert data into the table: "news" */
  readonly insert_news?: Maybe<NewsMutationResponse>;
  /** insert a single row into the table: "news" */
  readonly insert_news_one?: Maybe<News>;
  /** insert data into the table: "news_summaries" */
  readonly insert_news_summaries?: Maybe<NewsSummariesMutationResponse>;
  /** insert a single row into the table: "news_summaries" */
  readonly insert_news_summaries_one?: Maybe<NewsSummaries>;
  /** insert data into the table: "news_tags" */
  readonly insert_news_tags?: Maybe<NewsTagsMutationResponse>;
  /** insert a single row into the table: "news_tags" */
  readonly insert_news_tags_one?: Maybe<NewsTags>;
  /** insert data into the table: "newsletters" */
  readonly insert_newsletters?: Maybe<NewslettersMutationResponse>;
  /** insert a single row into the table: "newsletters" */
  readonly insert_newsletters_one?: Maybe<Newsletters>;
  /** insert data into the table: "payment_providers" */
  readonly insert_payment_providers?: Maybe<PaymentProvidersMutationResponse>;
  /** insert a single row into the table: "payment_providers" */
  readonly insert_payment_providers_one?: Maybe<PaymentProviders>;
  /** insert data into the table: "plan_permissions" */
  readonly insert_plan_permissions?: Maybe<PlanPermissionsMutationResponse>;
  /** insert a single row into the table: "plan_permissions" */
  readonly insert_plan_permissions_one?: Maybe<PlanPermissions>;
  /** insert data into the table: "recent_errors" */
  readonly insert_recent_errors?: Maybe<RecentErrorsMutationResponse>;
  /** insert a single row into the table: "recent_errors" */
  readonly insert_recent_errors_one?: Maybe<RecentErrors>;
  /** insert data into the table: "referrals" */
  readonly insert_referrals?: Maybe<ReferralsMutationResponse>;
  /** insert a single row into the table: "referrals" */
  readonly insert_referrals_one?: Maybe<Referrals>;
  /** insert data into the table: "referrer_blocks" */
  readonly insert_referrer_blocks?: Maybe<ReferrerBlocksMutationResponse>;
  /** insert a single row into the table: "referrer_blocks" */
  readonly insert_referrer_blocks_one?: Maybe<ReferrerBlocks>;
  /** insert data into the table: "research" */
  readonly insert_research?: Maybe<ResearchMutationResponse>;
  /** insert data into the table: "research_embeddings" */
  readonly insert_research_embeddings?: Maybe<ResearchEmbeddingsMutationResponse>;
  /** insert a single row into the table: "research_embeddings" */
  readonly insert_research_embeddings_one?: Maybe<ResearchEmbeddings>;
  /** insert a single row into the table: "research" */
  readonly insert_research_one?: Maybe<Research>;
  /** insert data into the table: "responses" */
  readonly insert_responses?: Maybe<ResponsesMutationResponse>;
  /** insert a single row into the table: "responses" */
  readonly insert_responses_one?: Maybe<Responses>;
  /** insert data into the table: "role_hierarchy" */
  readonly insert_role_hierarchy?: Maybe<RoleHierarchyMutationResponse>;
  /** insert a single row into the table: "role_hierarchy" */
  readonly insert_role_hierarchy_one?: Maybe<RoleHierarchy>;
  /** insert data into the table: "role_permissions" */
  readonly insert_role_permissions?: Maybe<RolePermissionsMutationResponse>;
  /** insert data into the table: "role_permissions_materialized" */
  readonly insert_role_permissions_materialized?: Maybe<RolePermissionsMaterializedMutationResponse>;
  /** insert a single row into the table: "role_permissions_materialized" */
  readonly insert_role_permissions_materialized_one?: Maybe<RolePermissionsMaterialized>;
  /** insert a single row into the table: "role_permissions" */
  readonly insert_role_permissions_one?: Maybe<RolePermissions>;
  /** insert data into the table: "scoring_weights" */
  readonly insert_scoring_weights?: Maybe<ScoringWeightsMutationResponse>;
  /** insert a single row into the table: "scoring_weights" */
  readonly insert_scoring_weights_one?: Maybe<ScoringWeights>;
  /** insert data into the table: "searches" */
  readonly insert_searches?: Maybe<SearchesMutationResponse>;
  /** insert a single row into the table: "searches" */
  readonly insert_searches_one?: Maybe<Searches>;
  /** insert data into the table: "social_media" */
  readonly insert_social_media?: Maybe<SocialMediaMutationResponse>;
  /** insert a single row into the table: "social_media" */
  readonly insert_social_media_one?: Maybe<SocialMedia>;
  /** insert data into the table: "spider_metrics" */
  readonly insert_spider_metrics?: Maybe<SpiderMetricsMutationResponse>;
  /** insert a single row into the table: "spider_metrics" */
  readonly insert_spider_metrics_one?: Maybe<SpiderMetrics>;
  /** insert data into the table: "strapi_migrations" */
  readonly insert_strapi_migrations?: Maybe<StrapiMigrationsMutationResponse>;
  /** insert data into the table: "strapi_migrations_internal" */
  readonly insert_strapi_migrations_internal?: Maybe<StrapiMigrationsInternalMutationResponse>;
  /** insert a single row into the table: "strapi_migrations_internal" */
  readonly insert_strapi_migrations_internal_one?: Maybe<StrapiMigrationsInternal>;
  /** insert a single row into the table: "strapi_migrations" */
  readonly insert_strapi_migrations_one?: Maybe<StrapiMigrations>;
  /** insert data into the table: "table_maintenance_log" */
  readonly insert_table_maintenance_log?: Maybe<TableMaintenanceLogMutationResponse>;
  /** insert a single row into the table: "table_maintenance_log" */
  readonly insert_table_maintenance_log_one?: Maybe<TableMaintenanceLog>;
  /** insert data into the table: "table_query_performance" */
  readonly insert_table_query_performance?: Maybe<TableQueryPerformanceMutationResponse>;
  /** insert a single row into the table: "table_query_performance" */
  readonly insert_table_query_performance_one?: Maybe<TableQueryPerformance>;
  /** insert data into the table: "table_sequence_usage" */
  readonly insert_table_sequence_usage?: Maybe<TableSequenceUsageMutationResponse>;
  /** insert a single row into the table: "table_sequence_usage" */
  readonly insert_table_sequence_usage_one?: Maybe<TableSequenceUsage>;
  /** insert data into the table: "table_statistics" */
  readonly insert_table_statistics?: Maybe<TableStatisticsMutationResponse>;
  /** insert a single row into the table: "table_statistics" */
  readonly insert_table_statistics_one?: Maybe<TableStatistics>;
  /** insert data into the table: "tags" */
  readonly insert_tags?: Maybe<TagsMutationResponse>;
  /** insert a single row into the table: "tags" */
  readonly insert_tags_one?: Maybe<Tags>;
  /** insert data into the table: "user_metrics" */
  readonly insert_user_metrics?: Maybe<UserMetricsMutationResponse>;
  /** insert a single row into the table: "user_metrics" */
  readonly insert_user_metrics_one?: Maybe<UserMetrics>;
  /** insert data into the table: "user_profiles" */
  readonly insert_user_profiles?: Maybe<UserProfilesMutationResponse>;
  /** insert a single row into the table: "user_profiles" */
  readonly insert_user_profiles_one?: Maybe<UserProfiles>;
  /** insert data into the table: "votes" */
  readonly insert_votes?: Maybe<VotesMutationResponse>;
  /** insert a single row into the table: "votes" */
  readonly insert_votes_one?: Maybe<Votes>;
  /** insert data into the table: "workflows" */
  readonly insert_workflows?: Maybe<WorkflowsMutationResponse>;
  /** insert a single row into the table: "workflows" */
  readonly insert_workflows_one?: Maybe<Workflows>;
  /** execute VOLATILE function "match_research" which returns "research_embeddings" */
  readonly match_research: ReadonlyArray<ResearchEmbeddings>;
  /** update data of the table: "ad_daily_metrics" */
  readonly update_ad_daily_metrics?: Maybe<AdDailyMetricsMutationResponse>;
  /** update single row of the table: "ad_daily_metrics" */
  readonly update_ad_daily_metrics_by_pk?: Maybe<AdDailyMetrics>;
  /** update multiples rows of table: "ad_daily_metrics" */
  readonly update_ad_daily_metrics_many?: Maybe<
    ReadonlyArray<Maybe<AdDailyMetricsMutationResponse>>
  >;
  /** update data of the table: "ad_packages" */
  readonly update_ad_packages?: Maybe<AdPackagesMutationResponse>;
  /** update single row of the table: "ad_packages" */
  readonly update_ad_packages_by_pk?: Maybe<AdPackages>;
  /** update multiples rows of table: "ad_packages" */
  readonly update_ad_packages_many?: Maybe<
    ReadonlyArray<Maybe<AdPackagesMutationResponse>>
  >;
  /** update data of the table: "ad_variants" */
  readonly update_ad_variants?: Maybe<AdVariantsMutationResponse>;
  /** update single row of the table: "ad_variants" */
  readonly update_ad_variants_by_pk?: Maybe<AdVariants>;
  /** update multiples rows of table: "ad_variants" */
  readonly update_ad_variants_many?: Maybe<
    ReadonlyArray<Maybe<AdVariantsMutationResponse>>
  >;
  /** update data of the table: "addresses" */
  readonly update_addresses?: Maybe<AddressesMutationResponse>;
  /** update single row of the table: "addresses" */
  readonly update_addresses_by_pk?: Maybe<Addresses>;
  /** update multiples rows of table: "addresses" */
  readonly update_addresses_many?: Maybe<
    ReadonlyArray<Maybe<AddressesMutationResponse>>
  >;
  /** update data of the table: "ads" */
  readonly update_ads?: Maybe<AdsMutationResponse>;
  /** update single row of the table: "ads" */
  readonly update_ads_by_pk?: Maybe<Ads>;
  /** update multiples rows of table: "ads" */
  readonly update_ads_many?: Maybe<ReadonlyArray<Maybe<AdsMutationResponse>>>;
  /** update data of the table: "blacklisted_domains" */
  readonly update_blacklisted_domains?: Maybe<BlacklistedDomainsMutationResponse>;
  /** update single row of the table: "blacklisted_domains" */
  readonly update_blacklisted_domains_by_pk?: Maybe<BlacklistedDomains>;
  /** update multiples rows of table: "blacklisted_domains" */
  readonly update_blacklisted_domains_many?: Maybe<
    ReadonlyArray<Maybe<BlacklistedDomainsMutationResponse>>
  >;
  /** update data of the table: "blacklisted_urls" */
  readonly update_blacklisted_urls?: Maybe<BlacklistedUrlsMutationResponse>;
  /** update single row of the table: "blacklisted_urls" */
  readonly update_blacklisted_urls_by_pk?: Maybe<BlacklistedUrls>;
  /** update multiples rows of table: "blacklisted_urls" */
  readonly update_blacklisted_urls_many?: Maybe<
    ReadonlyArray<Maybe<BlacklistedUrlsMutationResponse>>
  >;
  /** update data of the table: "blocked_ips" */
  readonly update_blocked_ips?: Maybe<BlockedIpsMutationResponse>;
  /** update single row of the table: "blocked_ips" */
  readonly update_blocked_ips_by_pk?: Maybe<BlockedIps>;
  /** update multiples rows of table: "blocked_ips" */
  readonly update_blocked_ips_many?: Maybe<
    ReadonlyArray<Maybe<BlockedIpsMutationResponse>>
  >;
  /** update data of the table: "bookmark_folders" */
  readonly update_bookmark_folders?: Maybe<BookmarkFoldersMutationResponse>;
  /** update single row of the table: "bookmark_folders" */
  readonly update_bookmark_folders_by_pk?: Maybe<BookmarkFolders>;
  /** update multiples rows of table: "bookmark_folders" */
  readonly update_bookmark_folders_many?: Maybe<
    ReadonlyArray<Maybe<BookmarkFoldersMutationResponse>>
  >;
  /** update data of the table: "bookmarks" */
  readonly update_bookmarks?: Maybe<BookmarksMutationResponse>;
  /** update single row of the table: "bookmarks" */
  readonly update_bookmarks_by_pk?: Maybe<Bookmarks>;
  /** update multiples rows of table: "bookmarks" */
  readonly update_bookmarks_many?: Maybe<
    ReadonlyArray<Maybe<BookmarksMutationResponse>>
  >;
  /** update data of the table: "business_domains" */
  readonly update_business_domains?: Maybe<BusinessDomainsMutationResponse>;
  /** update single row of the table: "business_domains" */
  readonly update_business_domains_by_pk?: Maybe<BusinessDomains>;
  /** update multiples rows of table: "business_domains" */
  readonly update_business_domains_many?: Maybe<
    ReadonlyArray<Maybe<BusinessDomainsMutationResponse>>
  >;
  /** update data of the table: "categories" */
  readonly update_categories?: Maybe<CategoriesMutationResponse>;
  /** update single row of the table: "categories" */
  readonly update_categories_by_pk?: Maybe<Categories>;
  /** update multiples rows of table: "categories" */
  readonly update_categories_many?: Maybe<
    ReadonlyArray<Maybe<CategoriesMutationResponse>>
  >;
  /** update data of the table: "categorized_urls" */
  readonly update_categorized_urls?: Maybe<CategorizedUrlsMutationResponse>;
  /** update single row of the table: "categorized_urls" */
  readonly update_categorized_urls_by_pk?: Maybe<CategorizedUrls>;
  /** update multiples rows of table: "categorized_urls" */
  readonly update_categorized_urls_many?: Maybe<
    ReadonlyArray<Maybe<CategorizedUrlsMutationResponse>>
  >;
  /** update data of the table: "circuit_breaker_states" */
  readonly update_circuit_breaker_states?: Maybe<CircuitBreakerStatesMutationResponse>;
  /** update single row of the table: "circuit_breaker_states" */
  readonly update_circuit_breaker_states_by_pk?: Maybe<CircuitBreakerStates>;
  /** update multiples rows of table: "circuit_breaker_states" */
  readonly update_circuit_breaker_states_many?: Maybe<
    ReadonlyArray<Maybe<CircuitBreakerStatesMutationResponse>>
  >;
  /** update data of the table: "cities" */
  readonly update_cities?: Maybe<CitiesMutationResponse>;
  /** update single row of the table: "cities" */
  readonly update_cities_by_pk?: Maybe<Cities>;
  /** update multiples rows of table: "cities" */
  readonly update_cities_many?: Maybe<
    ReadonlyArray<Maybe<CitiesMutationResponse>>
  >;
  /** update data of the table: "comments" */
  readonly update_comments?: Maybe<CommentsMutationResponse>;
  /** update single row of the table: "comments" */
  readonly update_comments_by_pk?: Maybe<Comments>;
  /** update multiples rows of table: "comments" */
  readonly update_comments_many?: Maybe<
    ReadonlyArray<Maybe<CommentsMutationResponse>>
  >;
  /** update data of the table: "companies" */
  readonly update_companies?: Maybe<CompaniesMutationResponse>;
  /** update single row of the table: "companies" */
  readonly update_companies_by_pk?: Maybe<Companies>;
  /** update multiples rows of table: "companies" */
  readonly update_companies_many?: Maybe<
    ReadonlyArray<Maybe<CompaniesMutationResponse>>
  >;
  /** update data of the table: "company_contacts" */
  readonly update_company_contacts?: Maybe<CompanyContactsMutationResponse>;
  /** update single row of the table: "company_contacts" */
  readonly update_company_contacts_by_pk?: Maybe<CompanyContacts>;
  /** update multiples rows of table: "company_contacts" */
  readonly update_company_contacts_many?: Maybe<
    ReadonlyArray<Maybe<CompanyContactsMutationResponse>>
  >;
  /** update data of the table: "company_employees" */
  readonly update_company_employees?: Maybe<CompanyEmployeesMutationResponse>;
  /** update single row of the table: "company_employees" */
  readonly update_company_employees_by_pk?: Maybe<CompanyEmployees>;
  /** update multiples rows of table: "company_employees" */
  readonly update_company_employees_many?: Maybe<
    ReadonlyArray<Maybe<CompanyEmployeesMutationResponse>>
  >;
  /** update data of the table: "company_extras" */
  readonly update_company_extras?: Maybe<CompanyExtrasMutationResponse>;
  /** update single row of the table: "company_extras" */
  readonly update_company_extras_by_pk?: Maybe<CompanyExtras>;
  /** update multiples rows of table: "company_extras" */
  readonly update_company_extras_many?: Maybe<
    ReadonlyArray<Maybe<CompanyExtrasMutationResponse>>
  >;
  /** update data of the table: "company_metrics" */
  readonly update_company_metrics?: Maybe<CompanyMetricsMutationResponse>;
  /** update single row of the table: "company_metrics" */
  readonly update_company_metrics_by_pk?: Maybe<CompanyMetrics>;
  /** update multiples rows of table: "company_metrics" */
  readonly update_company_metrics_many?: Maybe<
    ReadonlyArray<Maybe<CompanyMetricsMutationResponse>>
  >;
  /** update data of the table: "contacts" */
  readonly update_contacts?: Maybe<ContactsMutationResponse>;
  /** update single row of the table: "contacts" */
  readonly update_contacts_by_pk?: Maybe<Contacts>;
  /** update multiples rows of table: "contacts" */
  readonly update_contacts_many?: Maybe<
    ReadonlyArray<Maybe<ContactsMutationResponse>>
  >;
  /** update data of the table: "content_categories" */
  readonly update_content_categories?: Maybe<ContentCategoriesMutationResponse>;
  /** update single row of the table: "content_categories" */
  readonly update_content_categories_by_pk?: Maybe<ContentCategories>;
  /** update multiples rows of table: "content_categories" */
  readonly update_content_categories_many?: Maybe<
    ReadonlyArray<Maybe<ContentCategoriesMutationResponse>>
  >;
  /** update data of the table: "content_source_visits" */
  readonly update_content_source_visits?: Maybe<ContentSourceVisitsMutationResponse>;
  /** update single row of the table: "content_source_visits" */
  readonly update_content_source_visits_by_pk?: Maybe<ContentSourceVisits>;
  /** update multiples rows of table: "content_source_visits" */
  readonly update_content_source_visits_many?: Maybe<
    ReadonlyArray<Maybe<ContentSourceVisitsMutationResponse>>
  >;
  /** update data of the table: "content_sources" */
  readonly update_content_sources?: Maybe<ContentSourcesMutationResponse>;
  /** update single row of the table: "content_sources" */
  readonly update_content_sources_by_pk?: Maybe<ContentSources>;
  /** update multiples rows of table: "content_sources" */
  readonly update_content_sources_many?: Maybe<
    ReadonlyArray<Maybe<ContentSourcesMutationResponse>>
  >;
  /** update data of the table: "content_statuses" */
  readonly update_content_statuses?: Maybe<ContentStatusesMutationResponse>;
  /** update single row of the table: "content_statuses" */
  readonly update_content_statuses_by_pk?: Maybe<ContentStatuses>;
  /** update multiples rows of table: "content_statuses" */
  readonly update_content_statuses_many?: Maybe<
    ReadonlyArray<Maybe<ContentStatusesMutationResponse>>
  >;
  /** update data of the table: "content_tags" */
  readonly update_content_tags?: Maybe<ContentTagsMutationResponse>;
  /** update single row of the table: "content_tags" */
  readonly update_content_tags_by_pk?: Maybe<ContentTags>;
  /** update multiples rows of table: "content_tags" */
  readonly update_content_tags_many?: Maybe<
    ReadonlyArray<Maybe<ContentTagsMutationResponse>>
  >;
  /** update data of the table: "contents" */
  readonly update_contents?: Maybe<ContentsMutationResponse>;
  /** update single row of the table: "contents" */
  readonly update_contents_by_pk?: Maybe<Contents>;
  /** update multiples rows of table: "contents" */
  readonly update_contents_many?: Maybe<
    ReadonlyArray<Maybe<ContentsMutationResponse>>
  >;
  /** update data of the table: "countries" */
  readonly update_countries?: Maybe<CountriesMutationResponse>;
  /** update single row of the table: "countries" */
  readonly update_countries_by_pk?: Maybe<Countries>;
  /** update multiples rows of table: "countries" */
  readonly update_countries_many?: Maybe<
    ReadonlyArray<Maybe<CountriesMutationResponse>>
  >;
  /** update data of the table: "customer_payments" */
  readonly update_customer_payments?: Maybe<CustomerPaymentsMutationResponse>;
  /** update single row of the table: "customer_payments" */
  readonly update_customer_payments_by_pk?: Maybe<CustomerPayments>;
  /** update multiples rows of table: "customer_payments" */
  readonly update_customer_payments_many?: Maybe<
    ReadonlyArray<Maybe<CustomerPaymentsMutationResponse>>
  >;
  /** update data of the table: "customer_processed_webhooks" */
  readonly update_customer_processed_webhooks?: Maybe<CustomerProcessedWebhooksMutationResponse>;
  /** update single row of the table: "customer_processed_webhooks" */
  readonly update_customer_processed_webhooks_by_pk?: Maybe<CustomerProcessedWebhooks>;
  /** update multiples rows of table: "customer_processed_webhooks" */
  readonly update_customer_processed_webhooks_many?: Maybe<
    ReadonlyArray<Maybe<CustomerProcessedWebhooksMutationResponse>>
  >;
  /** update data of the table: "customer_refunds" */
  readonly update_customer_refunds?: Maybe<CustomerRefundsMutationResponse>;
  /** update single row of the table: "customer_refunds" */
  readonly update_customer_refunds_by_pk?: Maybe<CustomerRefunds>;
  /** update multiples rows of table: "customer_refunds" */
  readonly update_customer_refunds_many?: Maybe<
    ReadonlyArray<Maybe<CustomerRefundsMutationResponse>>
  >;
  /** update data of the table: "customer_subscription_plans" */
  readonly update_customer_subscription_plans?: Maybe<CustomerSubscriptionPlansMutationResponse>;
  /** update single row of the table: "customer_subscription_plans" */
  readonly update_customer_subscription_plans_by_pk?: Maybe<CustomerSubscriptionPlans>;
  /** update multiples rows of table: "customer_subscription_plans" */
  readonly update_customer_subscription_plans_many?: Maybe<
    ReadonlyArray<Maybe<CustomerSubscriptionPlansMutationResponse>>
  >;
  /** update data of the table: "customer_subscriptions" */
  readonly update_customer_subscriptions?: Maybe<CustomerSubscriptionsMutationResponse>;
  /** update single row of the table: "customer_subscriptions" */
  readonly update_customer_subscriptions_by_pk?: Maybe<CustomerSubscriptions>;
  /** update multiples rows of table: "customer_subscriptions" */
  readonly update_customer_subscriptions_many?: Maybe<
    ReadonlyArray<Maybe<CustomerSubscriptionsMutationResponse>>
  >;
  /** update data of the table: "embedding_reviews" */
  readonly update_embedding_reviews?: Maybe<EmbeddingReviewsMutationResponse>;
  /** update single row of the table: "embedding_reviews" */
  readonly update_embedding_reviews_by_pk?: Maybe<EmbeddingReviews>;
  /** update multiples rows of table: "embedding_reviews" */
  readonly update_embedding_reviews_many?: Maybe<
    ReadonlyArray<Maybe<EmbeddingReviewsMutationResponse>>
  >;
  /** update data of the table: "error_logs" */
  readonly update_error_logs?: Maybe<ErrorLogsMutationResponse>;
  /** update single row of the table: "error_logs" */
  readonly update_error_logs_by_pk?: Maybe<ErrorLogs>;
  /** update multiples rows of table: "error_logs" */
  readonly update_error_logs_many?: Maybe<
    ReadonlyArray<Maybe<ErrorLogsMutationResponse>>
  >;
  /** update data of the table: "feature_requests" */
  readonly update_feature_requests?: Maybe<FeatureRequestsMutationResponse>;
  /** update single row of the table: "feature_requests" */
  readonly update_feature_requests_by_pk?: Maybe<FeatureRequests>;
  /** update multiples rows of table: "feature_requests" */
  readonly update_feature_requests_many?: Maybe<
    ReadonlyArray<Maybe<FeatureRequestsMutationResponse>>
  >;
  /** update data of the table: "feature_votes" */
  readonly update_feature_votes?: Maybe<FeatureVotesMutationResponse>;
  /** update single row of the table: "feature_votes" */
  readonly update_feature_votes_by_pk?: Maybe<FeatureVotes>;
  /** update multiples rows of table: "feature_votes" */
  readonly update_feature_votes_many?: Maybe<
    ReadonlyArray<Maybe<FeatureVotesMutationResponse>>
  >;
  /** update data of the table: "feed_categories" */
  readonly update_feed_categories?: Maybe<FeedCategoriesMutationResponse>;
  /** update single row of the table: "feed_categories" */
  readonly update_feed_categories_by_pk?: Maybe<FeedCategories>;
  /** update multiples rows of table: "feed_categories" */
  readonly update_feed_categories_many?: Maybe<
    ReadonlyArray<Maybe<FeedCategoriesMutationResponse>>
  >;
  /** update data of the table: "feed_sources" */
  readonly update_feed_sources?: Maybe<FeedSourcesMutationResponse>;
  /** update single row of the table: "feed_sources" */
  readonly update_feed_sources_by_pk?: Maybe<FeedSources>;
  /** update multiples rows of table: "feed_sources" */
  readonly update_feed_sources_many?: Maybe<
    ReadonlyArray<Maybe<FeedSourcesMutationResponse>>
  >;
  /** update data of the table: "feedbacks" */
  readonly update_feedbacks?: Maybe<FeedbacksMutationResponse>;
  /** update single row of the table: "feedbacks" */
  readonly update_feedbacks_by_pk?: Maybe<Feedbacks>;
  /** update multiples rows of table: "feedbacks" */
  readonly update_feedbacks_many?: Maybe<
    ReadonlyArray<Maybe<FeedbacksMutationResponse>>
  >;
  /** update data of the table: "feeds" */
  readonly update_feeds?: Maybe<FeedsMutationResponse>;
  /** update single row of the table: "feeds" */
  readonly update_feeds_by_pk?: Maybe<Feeds>;
  /** update multiples rows of table: "feeds" */
  readonly update_feeds_many?: Maybe<
    ReadonlyArray<Maybe<FeedsMutationResponse>>
  >;
  /** update data of the table: "follows" */
  readonly update_follows?: Maybe<FollowsMutationResponse>;
  /** update single row of the table: "follows" */
  readonly update_follows_by_pk?: Maybe<Follows>;
  /** update multiples rows of table: "follows" */
  readonly update_follows_many?: Maybe<
    ReadonlyArray<Maybe<FollowsMutationResponse>>
  >;
  /** update data of the table: "metric_definitions" */
  readonly update_metric_definitions?: Maybe<MetricDefinitionsMutationResponse>;
  /** update single row of the table: "metric_definitions" */
  readonly update_metric_definitions_by_pk?: Maybe<MetricDefinitions>;
  /** update multiples rows of table: "metric_definitions" */
  readonly update_metric_definitions_many?: Maybe<
    ReadonlyArray<Maybe<MetricDefinitionsMutationResponse>>
  >;
  /** update data of the table: "news" */
  readonly update_news?: Maybe<NewsMutationResponse>;
  /** update single row of the table: "news" */
  readonly update_news_by_pk?: Maybe<News>;
  /** update multiples rows of table: "news" */
  readonly update_news_many?: Maybe<ReadonlyArray<Maybe<NewsMutationResponse>>>;
  /** update data of the table: "news_summaries" */
  readonly update_news_summaries?: Maybe<NewsSummariesMutationResponse>;
  /** update single row of the table: "news_summaries" */
  readonly update_news_summaries_by_pk?: Maybe<NewsSummaries>;
  /** update multiples rows of table: "news_summaries" */
  readonly update_news_summaries_many?: Maybe<
    ReadonlyArray<Maybe<NewsSummariesMutationResponse>>
  >;
  /** update data of the table: "news_tags" */
  readonly update_news_tags?: Maybe<NewsTagsMutationResponse>;
  /** update single row of the table: "news_tags" */
  readonly update_news_tags_by_pk?: Maybe<NewsTags>;
  /** update multiples rows of table: "news_tags" */
  readonly update_news_tags_many?: Maybe<
    ReadonlyArray<Maybe<NewsTagsMutationResponse>>
  >;
  /** update data of the table: "newsletters" */
  readonly update_newsletters?: Maybe<NewslettersMutationResponse>;
  /** update single row of the table: "newsletters" */
  readonly update_newsletters_by_pk?: Maybe<Newsletters>;
  /** update multiples rows of table: "newsletters" */
  readonly update_newsletters_many?: Maybe<
    ReadonlyArray<Maybe<NewslettersMutationResponse>>
  >;
  /** update data of the table: "payment_providers" */
  readonly update_payment_providers?: Maybe<PaymentProvidersMutationResponse>;
  /** update single row of the table: "payment_providers" */
  readonly update_payment_providers_by_pk?: Maybe<PaymentProviders>;
  /** update multiples rows of table: "payment_providers" */
  readonly update_payment_providers_many?: Maybe<
    ReadonlyArray<Maybe<PaymentProvidersMutationResponse>>
  >;
  /** update data of the table: "plan_permissions" */
  readonly update_plan_permissions?: Maybe<PlanPermissionsMutationResponse>;
  /** update single row of the table: "plan_permissions" */
  readonly update_plan_permissions_by_pk?: Maybe<PlanPermissions>;
  /** update multiples rows of table: "plan_permissions" */
  readonly update_plan_permissions_many?: Maybe<
    ReadonlyArray<Maybe<PlanPermissionsMutationResponse>>
  >;
  /** update data of the table: "recent_errors" */
  readonly update_recent_errors?: Maybe<RecentErrorsMutationResponse>;
  /** update multiples rows of table: "recent_errors" */
  readonly update_recent_errors_many?: Maybe<
    ReadonlyArray<Maybe<RecentErrorsMutationResponse>>
  >;
  /** update data of the table: "referrals" */
  readonly update_referrals?: Maybe<ReferralsMutationResponse>;
  /** update single row of the table: "referrals" */
  readonly update_referrals_by_pk?: Maybe<Referrals>;
  /** update multiples rows of table: "referrals" */
  readonly update_referrals_many?: Maybe<
    ReadonlyArray<Maybe<ReferralsMutationResponse>>
  >;
  /** update data of the table: "referrer_blocks" */
  readonly update_referrer_blocks?: Maybe<ReferrerBlocksMutationResponse>;
  /** update single row of the table: "referrer_blocks" */
  readonly update_referrer_blocks_by_pk?: Maybe<ReferrerBlocks>;
  /** update multiples rows of table: "referrer_blocks" */
  readonly update_referrer_blocks_many?: Maybe<
    ReadonlyArray<Maybe<ReferrerBlocksMutationResponse>>
  >;
  /** update data of the table: "research" */
  readonly update_research?: Maybe<ResearchMutationResponse>;
  /** update single row of the table: "research" */
  readonly update_research_by_pk?: Maybe<Research>;
  /** update data of the table: "research_embeddings" */
  readonly update_research_embeddings?: Maybe<ResearchEmbeddingsMutationResponse>;
  /** update single row of the table: "research_embeddings" */
  readonly update_research_embeddings_by_pk?: Maybe<ResearchEmbeddings>;
  /** update multiples rows of table: "research_embeddings" */
  readonly update_research_embeddings_many?: Maybe<
    ReadonlyArray<Maybe<ResearchEmbeddingsMutationResponse>>
  >;
  /** update multiples rows of table: "research" */
  readonly update_research_many?: Maybe<
    ReadonlyArray<Maybe<ResearchMutationResponse>>
  >;
  /** update data of the table: "responses" */
  readonly update_responses?: Maybe<ResponsesMutationResponse>;
  /** update single row of the table: "responses" */
  readonly update_responses_by_pk?: Maybe<Responses>;
  /** update multiples rows of table: "responses" */
  readonly update_responses_many?: Maybe<
    ReadonlyArray<Maybe<ResponsesMutationResponse>>
  >;
  /** update data of the table: "role_hierarchy" */
  readonly update_role_hierarchy?: Maybe<RoleHierarchyMutationResponse>;
  /** update single row of the table: "role_hierarchy" */
  readonly update_role_hierarchy_by_pk?: Maybe<RoleHierarchy>;
  /** update multiples rows of table: "role_hierarchy" */
  readonly update_role_hierarchy_many?: Maybe<
    ReadonlyArray<Maybe<RoleHierarchyMutationResponse>>
  >;
  /** update data of the table: "role_permissions" */
  readonly update_role_permissions?: Maybe<RolePermissionsMutationResponse>;
  /** update single row of the table: "role_permissions" */
  readonly update_role_permissions_by_pk?: Maybe<RolePermissions>;
  /** update multiples rows of table: "role_permissions" */
  readonly update_role_permissions_many?: Maybe<
    ReadonlyArray<Maybe<RolePermissionsMutationResponse>>
  >;
  /** update data of the table: "role_permissions_materialized" */
  readonly update_role_permissions_materialized?: Maybe<RolePermissionsMaterializedMutationResponse>;
  /** update single row of the table: "role_permissions_materialized" */
  readonly update_role_permissions_materialized_by_pk?: Maybe<RolePermissionsMaterialized>;
  /** update multiples rows of table: "role_permissions_materialized" */
  readonly update_role_permissions_materialized_many?: Maybe<
    ReadonlyArray<Maybe<RolePermissionsMaterializedMutationResponse>>
  >;
  /** update data of the table: "scoring_weights" */
  readonly update_scoring_weights?: Maybe<ScoringWeightsMutationResponse>;
  /** update single row of the table: "scoring_weights" */
  readonly update_scoring_weights_by_pk?: Maybe<ScoringWeights>;
  /** update multiples rows of table: "scoring_weights" */
  readonly update_scoring_weights_many?: Maybe<
    ReadonlyArray<Maybe<ScoringWeightsMutationResponse>>
  >;
  /** update data of the table: "searches" */
  readonly update_searches?: Maybe<SearchesMutationResponse>;
  /** update single row of the table: "searches" */
  readonly update_searches_by_pk?: Maybe<Searches>;
  /** update multiples rows of table: "searches" */
  readonly update_searches_many?: Maybe<
    ReadonlyArray<Maybe<SearchesMutationResponse>>
  >;
  /** update data of the table: "social_media" */
  readonly update_social_media?: Maybe<SocialMediaMutationResponse>;
  /** update single row of the table: "social_media" */
  readonly update_social_media_by_pk?: Maybe<SocialMedia>;
  /** update multiples rows of table: "social_media" */
  readonly update_social_media_many?: Maybe<
    ReadonlyArray<Maybe<SocialMediaMutationResponse>>
  >;
  /** update data of the table: "spider_metrics" */
  readonly update_spider_metrics?: Maybe<SpiderMetricsMutationResponse>;
  /** update single row of the table: "spider_metrics" */
  readonly update_spider_metrics_by_pk?: Maybe<SpiderMetrics>;
  /** update multiples rows of table: "spider_metrics" */
  readonly update_spider_metrics_many?: Maybe<
    ReadonlyArray<Maybe<SpiderMetricsMutationResponse>>
  >;
  /** update data of the table: "strapi_migrations" */
  readonly update_strapi_migrations?: Maybe<StrapiMigrationsMutationResponse>;
  /** update single row of the table: "strapi_migrations" */
  readonly update_strapi_migrations_by_pk?: Maybe<StrapiMigrations>;
  /** update data of the table: "strapi_migrations_internal" */
  readonly update_strapi_migrations_internal?: Maybe<StrapiMigrationsInternalMutationResponse>;
  /** update single row of the table: "strapi_migrations_internal" */
  readonly update_strapi_migrations_internal_by_pk?: Maybe<StrapiMigrationsInternal>;
  /** update multiples rows of table: "strapi_migrations_internal" */
  readonly update_strapi_migrations_internal_many?: Maybe<
    ReadonlyArray<Maybe<StrapiMigrationsInternalMutationResponse>>
  >;
  /** update multiples rows of table: "strapi_migrations" */
  readonly update_strapi_migrations_many?: Maybe<
    ReadonlyArray<Maybe<StrapiMigrationsMutationResponse>>
  >;
  /** update data of the table: "table_maintenance_log" */
  readonly update_table_maintenance_log?: Maybe<TableMaintenanceLogMutationResponse>;
  /** update single row of the table: "table_maintenance_log" */
  readonly update_table_maintenance_log_by_pk?: Maybe<TableMaintenanceLog>;
  /** update multiples rows of table: "table_maintenance_log" */
  readonly update_table_maintenance_log_many?: Maybe<
    ReadonlyArray<Maybe<TableMaintenanceLogMutationResponse>>
  >;
  /** update data of the table: "table_query_performance" */
  readonly update_table_query_performance?: Maybe<TableQueryPerformanceMutationResponse>;
  /** update multiples rows of table: "table_query_performance" */
  readonly update_table_query_performance_many?: Maybe<
    ReadonlyArray<Maybe<TableQueryPerformanceMutationResponse>>
  >;
  /** update data of the table: "table_sequence_usage" */
  readonly update_table_sequence_usage?: Maybe<TableSequenceUsageMutationResponse>;
  /** update multiples rows of table: "table_sequence_usage" */
  readonly update_table_sequence_usage_many?: Maybe<
    ReadonlyArray<Maybe<TableSequenceUsageMutationResponse>>
  >;
  /** update data of the table: "table_statistics" */
  readonly update_table_statistics?: Maybe<TableStatisticsMutationResponse>;
  /** update single row of the table: "table_statistics" */
  readonly update_table_statistics_by_pk?: Maybe<TableStatistics>;
  /** update multiples rows of table: "table_statistics" */
  readonly update_table_statistics_many?: Maybe<
    ReadonlyArray<Maybe<TableStatisticsMutationResponse>>
  >;
  /** update data of the table: "tags" */
  readonly update_tags?: Maybe<TagsMutationResponse>;
  /** update single row of the table: "tags" */
  readonly update_tags_by_pk?: Maybe<Tags>;
  /** update multiples rows of table: "tags" */
  readonly update_tags_many?: Maybe<ReadonlyArray<Maybe<TagsMutationResponse>>>;
  /** update data of the table: "user_metrics" */
  readonly update_user_metrics?: Maybe<UserMetricsMutationResponse>;
  /** update single row of the table: "user_metrics" */
  readonly update_user_metrics_by_pk?: Maybe<UserMetrics>;
  /** update multiples rows of table: "user_metrics" */
  readonly update_user_metrics_many?: Maybe<
    ReadonlyArray<Maybe<UserMetricsMutationResponse>>
  >;
  /** update data of the table: "user_profiles" */
  readonly update_user_profiles?: Maybe<UserProfilesMutationResponse>;
  /** update single row of the table: "user_profiles" */
  readonly update_user_profiles_by_pk?: Maybe<UserProfiles>;
  /** update multiples rows of table: "user_profiles" */
  readonly update_user_profiles_many?: Maybe<
    ReadonlyArray<Maybe<UserProfilesMutationResponse>>
  >;
  /** update data of the table: "votes" */
  readonly update_votes?: Maybe<VotesMutationResponse>;
  /** update single row of the table: "votes" */
  readonly update_votes_by_pk?: Maybe<Votes>;
  /** update multiples rows of table: "votes" */
  readonly update_votes_many?: Maybe<
    ReadonlyArray<Maybe<VotesMutationResponse>>
  >;
  /** update data of the table: "workflows" */
  readonly update_workflows?: Maybe<WorkflowsMutationResponse>;
  /** update single row of the table: "workflows" */
  readonly update_workflows_by_pk?: Maybe<Workflows>;
  /** update multiples rows of table: "workflows" */
  readonly update_workflows_many?: Maybe<
    ReadonlyArray<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: ReadonlyArray<AdDailyMetricsInsertInput>;
  on_conflict?: InputMaybe<AdDailyMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertAdDailyMetricsOneArgs = {
  object: AdDailyMetricsInsertInput;
  on_conflict?: InputMaybe<AdDailyMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertAdPackagesArgs = {
  objects: ReadonlyArray<AdPackagesInsertInput>;
  on_conflict?: InputMaybe<AdPackagesOnConflict>;
};

/** mutation root */
export type MutationRootInsertAdPackagesOneArgs = {
  object: AdPackagesInsertInput;
  on_conflict?: InputMaybe<AdPackagesOnConflict>;
};

/** mutation root */
export type MutationRootInsertAdVariantsArgs = {
  objects: ReadonlyArray<AdVariantsInsertInput>;
  on_conflict?: InputMaybe<AdVariantsOnConflict>;
};

/** mutation root */
export type MutationRootInsertAdVariantsOneArgs = {
  object: AdVariantsInsertInput;
  on_conflict?: InputMaybe<AdVariantsOnConflict>;
};

/** mutation root */
export type MutationRootInsertAddressesArgs = {
  objects: ReadonlyArray<AddressesInsertInput>;
  on_conflict?: InputMaybe<AddressesOnConflict>;
};

/** mutation root */
export type MutationRootInsertAddressesOneArgs = {
  object: AddressesInsertInput;
  on_conflict?: InputMaybe<AddressesOnConflict>;
};

/** mutation root */
export type MutationRootInsertAdsArgs = {
  objects: ReadonlyArray<AdsInsertInput>;
  on_conflict?: InputMaybe<AdsOnConflict>;
};

/** mutation root */
export type MutationRootInsertAdsOneArgs = {
  object: AdsInsertInput;
  on_conflict?: InputMaybe<AdsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBlacklistedDomainsArgs = {
  objects: ReadonlyArray<BlacklistedDomainsInsertInput>;
  on_conflict?: InputMaybe<BlacklistedDomainsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBlacklistedDomainsOneArgs = {
  object: BlacklistedDomainsInsertInput;
  on_conflict?: InputMaybe<BlacklistedDomainsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBlacklistedUrlsArgs = {
  objects: ReadonlyArray<BlacklistedUrlsInsertInput>;
  on_conflict?: InputMaybe<BlacklistedUrlsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBlacklistedUrlsOneArgs = {
  object: BlacklistedUrlsInsertInput;
  on_conflict?: InputMaybe<BlacklistedUrlsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBlockedIpsArgs = {
  objects: ReadonlyArray<BlockedIpsInsertInput>;
  on_conflict?: InputMaybe<BlockedIpsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBlockedIpsOneArgs = {
  object: BlockedIpsInsertInput;
  on_conflict?: InputMaybe<BlockedIpsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBookmarkFoldersArgs = {
  objects: ReadonlyArray<BookmarkFoldersInsertInput>;
  on_conflict?: InputMaybe<BookmarkFoldersOnConflict>;
};

/** mutation root */
export type MutationRootInsertBookmarkFoldersOneArgs = {
  object: BookmarkFoldersInsertInput;
  on_conflict?: InputMaybe<BookmarkFoldersOnConflict>;
};

/** mutation root */
export type MutationRootInsertBookmarksArgs = {
  objects: ReadonlyArray<BookmarksInsertInput>;
  on_conflict?: InputMaybe<BookmarksOnConflict>;
};

/** mutation root */
export type MutationRootInsertBookmarksOneArgs = {
  object: BookmarksInsertInput;
  on_conflict?: InputMaybe<BookmarksOnConflict>;
};

/** mutation root */
export type MutationRootInsertBusinessDomainsArgs = {
  objects: ReadonlyArray<BusinessDomainsInsertInput>;
  on_conflict?: InputMaybe<BusinessDomainsOnConflict>;
};

/** mutation root */
export type MutationRootInsertBusinessDomainsOneArgs = {
  object: BusinessDomainsInsertInput;
  on_conflict?: InputMaybe<BusinessDomainsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCategoriesArgs = {
  objects: ReadonlyArray<CategoriesInsertInput>;
  on_conflict?: InputMaybe<CategoriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCategoriesOneArgs = {
  object: CategoriesInsertInput;
  on_conflict?: InputMaybe<CategoriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCategorizedUrlsArgs = {
  objects: ReadonlyArray<CategorizedUrlsInsertInput>;
  on_conflict?: InputMaybe<CategorizedUrlsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCategorizedUrlsOneArgs = {
  object: CategorizedUrlsInsertInput;
  on_conflict?: InputMaybe<CategorizedUrlsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCircuitBreakerStatesArgs = {
  objects: ReadonlyArray<CircuitBreakerStatesInsertInput>;
  on_conflict?: InputMaybe<CircuitBreakerStatesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCircuitBreakerStatesOneArgs = {
  object: CircuitBreakerStatesInsertInput;
  on_conflict?: InputMaybe<CircuitBreakerStatesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCitiesArgs = {
  objects: ReadonlyArray<CitiesInsertInput>;
  on_conflict?: InputMaybe<CitiesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCitiesOneArgs = {
  object: CitiesInsertInput;
  on_conflict?: InputMaybe<CitiesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCommentsArgs = {
  objects: ReadonlyArray<CommentsInsertInput>;
  on_conflict?: InputMaybe<CommentsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCommentsOneArgs = {
  object: CommentsInsertInput;
  on_conflict?: InputMaybe<CommentsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompaniesArgs = {
  objects: ReadonlyArray<CompaniesInsertInput>;
  on_conflict?: InputMaybe<CompaniesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompaniesOneArgs = {
  object: CompaniesInsertInput;
  on_conflict?: InputMaybe<CompaniesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyContactsArgs = {
  objects: ReadonlyArray<CompanyContactsInsertInput>;
  on_conflict?: InputMaybe<CompanyContactsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyContactsOneArgs = {
  object: CompanyContactsInsertInput;
  on_conflict?: InputMaybe<CompanyContactsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyEmployeesArgs = {
  objects: ReadonlyArray<CompanyEmployeesInsertInput>;
  on_conflict?: InputMaybe<CompanyEmployeesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyEmployeesOneArgs = {
  object: CompanyEmployeesInsertInput;
  on_conflict?: InputMaybe<CompanyEmployeesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyExtrasArgs = {
  objects: ReadonlyArray<CompanyExtrasInsertInput>;
  on_conflict?: InputMaybe<CompanyExtrasOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyExtrasOneArgs = {
  object: CompanyExtrasInsertInput;
  on_conflict?: InputMaybe<CompanyExtrasOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyMetricsArgs = {
  objects: ReadonlyArray<CompanyMetricsInsertInput>;
  on_conflict?: InputMaybe<CompanyMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCompanyMetricsOneArgs = {
  object: CompanyMetricsInsertInput;
  on_conflict?: InputMaybe<CompanyMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContactsArgs = {
  objects: ReadonlyArray<ContactsInsertInput>;
  on_conflict?: InputMaybe<ContactsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContactsOneArgs = {
  object: ContactsInsertInput;
  on_conflict?: InputMaybe<ContactsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentCategoriesArgs = {
  objects: ReadonlyArray<ContentCategoriesInsertInput>;
  on_conflict?: InputMaybe<ContentCategoriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentCategoriesOneArgs = {
  object: ContentCategoriesInsertInput;
  on_conflict?: InputMaybe<ContentCategoriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentSourceVisitsArgs = {
  objects: ReadonlyArray<ContentSourceVisitsInsertInput>;
  on_conflict?: InputMaybe<ContentSourceVisitsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentSourceVisitsOneArgs = {
  object: ContentSourceVisitsInsertInput;
  on_conflict?: InputMaybe<ContentSourceVisitsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentSourcesArgs = {
  objects: ReadonlyArray<ContentSourcesInsertInput>;
  on_conflict?: InputMaybe<ContentSourcesOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentSourcesOneArgs = {
  object: ContentSourcesInsertInput;
  on_conflict?: InputMaybe<ContentSourcesOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentStatusesArgs = {
  objects: ReadonlyArray<ContentStatusesInsertInput>;
  on_conflict?: InputMaybe<ContentStatusesOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentStatusesOneArgs = {
  object: ContentStatusesInsertInput;
  on_conflict?: InputMaybe<ContentStatusesOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentTagsArgs = {
  objects: ReadonlyArray<ContentTagsInsertInput>;
  on_conflict?: InputMaybe<ContentTagsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentTagsOneArgs = {
  object: ContentTagsInsertInput;
  on_conflict?: InputMaybe<ContentTagsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentsArgs = {
  objects: ReadonlyArray<ContentsInsertInput>;
  on_conflict?: InputMaybe<ContentsOnConflict>;
};

/** mutation root */
export type MutationRootInsertContentsOneArgs = {
  object: ContentsInsertInput;
  on_conflict?: InputMaybe<ContentsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCountriesArgs = {
  objects: ReadonlyArray<CountriesInsertInput>;
  on_conflict?: InputMaybe<CountriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCountriesOneArgs = {
  object: CountriesInsertInput;
  on_conflict?: InputMaybe<CountriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerPaymentsArgs = {
  objects: ReadonlyArray<CustomerPaymentsInsertInput>;
  on_conflict?: InputMaybe<CustomerPaymentsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerPaymentsOneArgs = {
  object: CustomerPaymentsInsertInput;
  on_conflict?: InputMaybe<CustomerPaymentsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerProcessedWebhooksArgs = {
  objects: ReadonlyArray<CustomerProcessedWebhooksInsertInput>;
  on_conflict?: InputMaybe<CustomerProcessedWebhooksOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerProcessedWebhooksOneArgs = {
  object: CustomerProcessedWebhooksInsertInput;
  on_conflict?: InputMaybe<CustomerProcessedWebhooksOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerRefundsArgs = {
  objects: ReadonlyArray<CustomerRefundsInsertInput>;
  on_conflict?: InputMaybe<CustomerRefundsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerRefundsOneArgs = {
  object: CustomerRefundsInsertInput;
  on_conflict?: InputMaybe<CustomerRefundsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerSubscriptionPlansArgs = {
  objects: ReadonlyArray<CustomerSubscriptionPlansInsertInput>;
  on_conflict?: InputMaybe<CustomerSubscriptionPlansOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerSubscriptionPlansOneArgs = {
  object: CustomerSubscriptionPlansInsertInput;
  on_conflict?: InputMaybe<CustomerSubscriptionPlansOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerSubscriptionsArgs = {
  objects: ReadonlyArray<CustomerSubscriptionsInsertInput>;
  on_conflict?: InputMaybe<CustomerSubscriptionsOnConflict>;
};

/** mutation root */
export type MutationRootInsertCustomerSubscriptionsOneArgs = {
  object: CustomerSubscriptionsInsertInput;
  on_conflict?: InputMaybe<CustomerSubscriptionsOnConflict>;
};

/** mutation root */
export type MutationRootInsertEmbeddingReviewsArgs = {
  objects: ReadonlyArray<EmbeddingReviewsInsertInput>;
  on_conflict?: InputMaybe<EmbeddingReviewsOnConflict>;
};

/** mutation root */
export type MutationRootInsertEmbeddingReviewsOneArgs = {
  object: EmbeddingReviewsInsertInput;
  on_conflict?: InputMaybe<EmbeddingReviewsOnConflict>;
};

/** mutation root */
export type MutationRootInsertErrorLogsArgs = {
  objects: ReadonlyArray<ErrorLogsInsertInput>;
  on_conflict?: InputMaybe<ErrorLogsOnConflict>;
};

/** mutation root */
export type MutationRootInsertErrorLogsOneArgs = {
  object: ErrorLogsInsertInput;
  on_conflict?: InputMaybe<ErrorLogsOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeatureRequestsArgs = {
  objects: ReadonlyArray<FeatureRequestsInsertInput>;
  on_conflict?: InputMaybe<FeatureRequestsOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeatureRequestsOneArgs = {
  object: FeatureRequestsInsertInput;
  on_conflict?: InputMaybe<FeatureRequestsOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeatureVotesArgs = {
  objects: ReadonlyArray<FeatureVotesInsertInput>;
  on_conflict?: InputMaybe<FeatureVotesOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeatureVotesOneArgs = {
  object: FeatureVotesInsertInput;
  on_conflict?: InputMaybe<FeatureVotesOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedCategoriesArgs = {
  objects: ReadonlyArray<FeedCategoriesInsertInput>;
  on_conflict?: InputMaybe<FeedCategoriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedCategoriesOneArgs = {
  object: FeedCategoriesInsertInput;
  on_conflict?: InputMaybe<FeedCategoriesOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedSourcesArgs = {
  objects: ReadonlyArray<FeedSourcesInsertInput>;
  on_conflict?: InputMaybe<FeedSourcesOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedSourcesOneArgs = {
  object: FeedSourcesInsertInput;
  on_conflict?: InputMaybe<FeedSourcesOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedbacksArgs = {
  objects: ReadonlyArray<FeedbacksInsertInput>;
  on_conflict?: InputMaybe<FeedbacksOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedbacksOneArgs = {
  object: FeedbacksInsertInput;
  on_conflict?: InputMaybe<FeedbacksOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedsArgs = {
  objects: ReadonlyArray<FeedsInsertInput>;
  on_conflict?: InputMaybe<FeedsOnConflict>;
};

/** mutation root */
export type MutationRootInsertFeedsOneArgs = {
  object: FeedsInsertInput;
  on_conflict?: InputMaybe<FeedsOnConflict>;
};

/** mutation root */
export type MutationRootInsertFollowsArgs = {
  objects: ReadonlyArray<FollowsInsertInput>;
  on_conflict?: InputMaybe<FollowsOnConflict>;
};

/** mutation root */
export type MutationRootInsertFollowsOneArgs = {
  object: FollowsInsertInput;
  on_conflict?: InputMaybe<FollowsOnConflict>;
};

/** mutation root */
export type MutationRootInsertMetricDefinitionsArgs = {
  objects: ReadonlyArray<MetricDefinitionsInsertInput>;
  on_conflict?: InputMaybe<MetricDefinitionsOnConflict>;
};

/** mutation root */
export type MutationRootInsertMetricDefinitionsOneArgs = {
  object: MetricDefinitionsInsertInput;
  on_conflict?: InputMaybe<MetricDefinitionsOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewsArgs = {
  objects: ReadonlyArray<NewsInsertInput>;
  on_conflict?: InputMaybe<NewsOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewsOneArgs = {
  object: NewsInsertInput;
  on_conflict?: InputMaybe<NewsOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewsSummariesArgs = {
  objects: ReadonlyArray<NewsSummariesInsertInput>;
  on_conflict?: InputMaybe<NewsSummariesOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewsSummariesOneArgs = {
  object: NewsSummariesInsertInput;
  on_conflict?: InputMaybe<NewsSummariesOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewsTagsArgs = {
  objects: ReadonlyArray<NewsTagsInsertInput>;
  on_conflict?: InputMaybe<NewsTagsOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewsTagsOneArgs = {
  object: NewsTagsInsertInput;
  on_conflict?: InputMaybe<NewsTagsOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewslettersArgs = {
  objects: ReadonlyArray<NewslettersInsertInput>;
  on_conflict?: InputMaybe<NewslettersOnConflict>;
};

/** mutation root */
export type MutationRootInsertNewslettersOneArgs = {
  object: NewslettersInsertInput;
  on_conflict?: InputMaybe<NewslettersOnConflict>;
};

/** mutation root */
export type MutationRootInsertPaymentProvidersArgs = {
  objects: ReadonlyArray<PaymentProvidersInsertInput>;
  on_conflict?: InputMaybe<PaymentProvidersOnConflict>;
};

/** mutation root */
export type MutationRootInsertPaymentProvidersOneArgs = {
  object: PaymentProvidersInsertInput;
  on_conflict?: InputMaybe<PaymentProvidersOnConflict>;
};

/** mutation root */
export type MutationRootInsertPlanPermissionsArgs = {
  objects: ReadonlyArray<PlanPermissionsInsertInput>;
  on_conflict?: InputMaybe<PlanPermissionsOnConflict>;
};

/** mutation root */
export type MutationRootInsertPlanPermissionsOneArgs = {
  object: PlanPermissionsInsertInput;
  on_conflict?: InputMaybe<PlanPermissionsOnConflict>;
};

/** mutation root */
export type MutationRootInsertRecentErrorsArgs = {
  objects: ReadonlyArray<RecentErrorsInsertInput>;
};

/** mutation root */
export type MutationRootInsertRecentErrorsOneArgs = {
  object: RecentErrorsInsertInput;
};

/** mutation root */
export type MutationRootInsertReferralsArgs = {
  objects: ReadonlyArray<ReferralsInsertInput>;
  on_conflict?: InputMaybe<ReferralsOnConflict>;
};

/** mutation root */
export type MutationRootInsertReferralsOneArgs = {
  object: ReferralsInsertInput;
  on_conflict?: InputMaybe<ReferralsOnConflict>;
};

/** mutation root */
export type MutationRootInsertReferrerBlocksArgs = {
  objects: ReadonlyArray<ReferrerBlocksInsertInput>;
  on_conflict?: InputMaybe<ReferrerBlocksOnConflict>;
};

/** mutation root */
export type MutationRootInsertReferrerBlocksOneArgs = {
  object: ReferrerBlocksInsertInput;
  on_conflict?: InputMaybe<ReferrerBlocksOnConflict>;
};

/** mutation root */
export type MutationRootInsertResearchArgs = {
  objects: ReadonlyArray<ResearchInsertInput>;
  on_conflict?: InputMaybe<ResearchOnConflict>;
};

/** mutation root */
export type MutationRootInsertResearchEmbeddingsArgs = {
  objects: ReadonlyArray<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: ReadonlyArray<ResponsesInsertInput>;
  on_conflict?: InputMaybe<ResponsesOnConflict>;
};

/** mutation root */
export type MutationRootInsertResponsesOneArgs = {
  object: ResponsesInsertInput;
  on_conflict?: InputMaybe<ResponsesOnConflict>;
};

/** mutation root */
export type MutationRootInsertRoleHierarchyArgs = {
  objects: ReadonlyArray<RoleHierarchyInsertInput>;
  on_conflict?: InputMaybe<RoleHierarchyOnConflict>;
};

/** mutation root */
export type MutationRootInsertRoleHierarchyOneArgs = {
  object: RoleHierarchyInsertInput;
  on_conflict?: InputMaybe<RoleHierarchyOnConflict>;
};

/** mutation root */
export type MutationRootInsertRolePermissionsArgs = {
  objects: ReadonlyArray<RolePermissionsInsertInput>;
  on_conflict?: InputMaybe<RolePermissionsOnConflict>;
};

/** mutation root */
export type MutationRootInsertRolePermissionsMaterializedArgs = {
  objects: ReadonlyArray<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: ReadonlyArray<ScoringWeightsInsertInput>;
  on_conflict?: InputMaybe<ScoringWeightsOnConflict>;
};

/** mutation root */
export type MutationRootInsertScoringWeightsOneArgs = {
  object: ScoringWeightsInsertInput;
  on_conflict?: InputMaybe<ScoringWeightsOnConflict>;
};

/** mutation root */
export type MutationRootInsertSearchesArgs = {
  objects: ReadonlyArray<SearchesInsertInput>;
  on_conflict?: InputMaybe<SearchesOnConflict>;
};

/** mutation root */
export type MutationRootInsertSearchesOneArgs = {
  object: SearchesInsertInput;
  on_conflict?: InputMaybe<SearchesOnConflict>;
};

/** mutation root */
export type MutationRootInsertSocialMediaArgs = {
  objects: ReadonlyArray<SocialMediaInsertInput>;
  on_conflict?: InputMaybe<SocialMediaOnConflict>;
};

/** mutation root */
export type MutationRootInsertSocialMediaOneArgs = {
  object: SocialMediaInsertInput;
  on_conflict?: InputMaybe<SocialMediaOnConflict>;
};

/** mutation root */
export type MutationRootInsertSpiderMetricsArgs = {
  objects: ReadonlyArray<SpiderMetricsInsertInput>;
  on_conflict?: InputMaybe<SpiderMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertSpiderMetricsOneArgs = {
  object: SpiderMetricsInsertInput;
  on_conflict?: InputMaybe<SpiderMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertStrapiMigrationsArgs = {
  objects: ReadonlyArray<StrapiMigrationsInsertInput>;
  on_conflict?: InputMaybe<StrapiMigrationsOnConflict>;
};

/** mutation root */
export type MutationRootInsertStrapiMigrationsInternalArgs = {
  objects: ReadonlyArray<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: ReadonlyArray<TableMaintenanceLogInsertInput>;
  on_conflict?: InputMaybe<TableMaintenanceLogOnConflict>;
};

/** mutation root */
export type MutationRootInsertTableMaintenanceLogOneArgs = {
  object: TableMaintenanceLogInsertInput;
  on_conflict?: InputMaybe<TableMaintenanceLogOnConflict>;
};

/** mutation root */
export type MutationRootInsertTableQueryPerformanceArgs = {
  objects: ReadonlyArray<TableQueryPerformanceInsertInput>;
  on_conflict?: InputMaybe<TableQueryPerformanceOnConflict>;
};

/** mutation root */
export type MutationRootInsertTableQueryPerformanceOneArgs = {
  object: TableQueryPerformanceInsertInput;
  on_conflict?: InputMaybe<TableQueryPerformanceOnConflict>;
};

/** mutation root */
export type MutationRootInsertTableSequenceUsageArgs = {
  objects: ReadonlyArray<TableSequenceUsageInsertInput>;
  on_conflict?: InputMaybe<TableSequenceUsageOnConflict>;
};

/** mutation root */
export type MutationRootInsertTableSequenceUsageOneArgs = {
  object: TableSequenceUsageInsertInput;
  on_conflict?: InputMaybe<TableSequenceUsageOnConflict>;
};

/** mutation root */
export type MutationRootInsertTableStatisticsArgs = {
  objects: ReadonlyArray<TableStatisticsInsertInput>;
  on_conflict?: InputMaybe<TableStatisticsOnConflict>;
};

/** mutation root */
export type MutationRootInsertTableStatisticsOneArgs = {
  object: TableStatisticsInsertInput;
  on_conflict?: InputMaybe<TableStatisticsOnConflict>;
};

/** mutation root */
export type MutationRootInsertTagsArgs = {
  objects: ReadonlyArray<TagsInsertInput>;
  on_conflict?: InputMaybe<TagsOnConflict>;
};

/** mutation root */
export type MutationRootInsertTagsOneArgs = {
  object: TagsInsertInput;
  on_conflict?: InputMaybe<TagsOnConflict>;
};

/** mutation root */
export type MutationRootInsertUserMetricsArgs = {
  objects: ReadonlyArray<UserMetricsInsertInput>;
  on_conflict?: InputMaybe<UserMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertUserMetricsOneArgs = {
  object: UserMetricsInsertInput;
  on_conflict?: InputMaybe<UserMetricsOnConflict>;
};

/** mutation root */
export type MutationRootInsertUserProfilesArgs = {
  objects: ReadonlyArray<UserProfilesInsertInput>;
  on_conflict?: InputMaybe<UserProfilesOnConflict>;
};

/** mutation root */
export type MutationRootInsertUserProfilesOneArgs = {
  object: UserProfilesInsertInput;
  on_conflict?: InputMaybe<UserProfilesOnConflict>;
};

/** mutation root */
export type MutationRootInsertVotesArgs = {
  objects: ReadonlyArray<VotesInsertInput>;
  on_conflict?: InputMaybe<VotesOnConflict>;
};

/** mutation root */
export type MutationRootInsertVotesOneArgs = {
  object: VotesInsertInput;
  on_conflict?: InputMaybe<VotesOnConflict>;
};

/** mutation root */
export type MutationRootInsertWorkflowsArgs = {
  objects: ReadonlyArray<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<ReadonlyArray<ResearchEmbeddingsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<ResearchEmbeddingsUpdates>;
};

/** mutation root */
export type MutationRootUpdateResearchManyArgs = {
  updates: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<StrapiMigrationsInternalUpdates>;
};

/** mutation root */
export type MutationRootUpdateStrapiMigrationsManyArgs = {
  updates: ReadonlyArray<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: ReadonlyArray<TableMaintenanceLogUpdates>;
};

/** mutation root */
export type MutationRootUpdateTableQueryPerformanceArgs = {
  _inc?: InputMaybe<TableQueryPerformanceIncInput>;
  _set?: InputMaybe<TableQueryPerformanceSetInput>;
  where: TableQueryPerformanceBoolExp;
};

/** mutation root */
export type MutationRootUpdateTableQueryPerformanceManyArgs = {
  updates: ReadonlyArray<TableQueryPerformanceUpdates>;
};

/** mutation root */
export type MutationRootUpdateTableSequenceUsageArgs = {
  _inc?: InputMaybe<TableSequenceUsageIncInput>;
  _set?: InputMaybe<TableSequenceUsageSetInput>;
  where: TableSequenceUsageBoolExp;
};

/** mutation root */
export type MutationRootUpdateTableSequenceUsageManyArgs = {
  updates: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<WorkflowsUpdates>;
};

/** columns and relationships of "news" */
export interface News {
  readonly author?: Maybe<Scalars["String"]["output"]>;
  readonly body?: Maybe<Scalars["String"]["output"]>;
  /** An object relationship */
  readonly category?: Maybe<Categories>;
  readonly category_id?: Maybe<Scalars["bigint"]["output"]>;
  /** An object relationship */
  readonly company?: Maybe<Companies>;
  readonly company_id?: Maybe<Scalars["uuid"]["output"]>;
  /** An object relationship */
  readonly content: Contents;
  /** An object relationship */
  readonly content_source?: Maybe<ContentSources>;
  readonly content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly content_status: Scalars["content_status"]["output"];
  readonly created_at: Scalars["timestamptz"]["output"];
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly failed_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly featured_image?: Maybe<Scalars["String"]["output"]>;
  readonly has_summary: Scalars["Boolean"]["output"];
  readonly hash?: Maybe<Scalars["bigint"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  readonly keywords?: Maybe<Scalars["jsonb"]["output"]>;
  /** An array relationship */
  readonly news_summaries: ReadonlyArray<NewsSummaries>;
  /** An aggregate relationship */
  readonly news_summaries_aggregate: NewsSummariesAggregate;
  readonly published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly scrape_frequency: Scalars["scrape_frequency"]["output"];
  readonly scraped_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at: Scalars["timestamptz"]["output"];
  readonly 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<ReadonlyArray<NewsSummariesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsSummariesOrderBy>>;
  where?: InputMaybe<NewsSummariesBoolExp>;
};

/** columns and relationships of "news" */
export type NewsNewsSummariesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsSummariesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsSummariesOrderBy>>;
  where?: InputMaybe<NewsSummariesBoolExp>;
};

/** aggregated selection of "news" */
export interface NewsAggregate {
  readonly aggregate?: Maybe<NewsAggregateFields>;
  readonly nodes: ReadonlyArray<News>;
}

export interface NewsAggregateBoolExp {
  readonly bool_and?: InputMaybe<NewsAggregateBoolExpBoolAnd>;
  readonly bool_or?: InputMaybe<NewsAggregateBoolExpBoolOr>;
  readonly count?: InputMaybe<NewsAggregateBoolExpCount>;
}

export interface NewsAggregateBoolExpBoolAnd {
  readonly arguments: NewsSelectColumnNewsAggregateBoolExpBoolAndArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<NewsBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface NewsAggregateBoolExpBoolOr {
  readonly arguments: NewsSelectColumnNewsAggregateBoolExpBoolOrArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<NewsBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface NewsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<NewsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<NewsBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "news" */
export interface NewsAggregateFields {
  readonly avg?: Maybe<NewsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<NewsMaxFields>;
  readonly min?: Maybe<NewsMinFields>;
  readonly stddev?: Maybe<NewsStddevFields>;
  readonly stddev_pop?: Maybe<NewsStddevPopFields>;
  readonly stddev_samp?: Maybe<NewsStddevSampFields>;
  readonly sum?: Maybe<NewsSumFields>;
  readonly var_pop?: Maybe<NewsVarPopFields>;
  readonly var_samp?: Maybe<NewsVarSampFields>;
  readonly variance?: Maybe<NewsVarianceFields>;
}

/** aggregate fields of "news" */
export type NewsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<NewsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "news" */
export interface NewsAggregateOrderBy {
  readonly avg?: InputMaybe<NewsAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<NewsMaxOrderBy>;
  readonly min?: InputMaybe<NewsMinOrderBy>;
  readonly stddev?: InputMaybe<NewsStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<NewsStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<NewsStddevSampOrderBy>;
  readonly sum?: InputMaybe<NewsSumOrderBy>;
  readonly var_pop?: InputMaybe<NewsVarPopOrderBy>;
  readonly var_samp?: InputMaybe<NewsVarSampOrderBy>;
  readonly variance?: InputMaybe<NewsVarianceOrderBy>;
}

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

/** input type for inserting array relation for remote table "news" */
export interface NewsArrRelInsertInput {
  readonly data: ReadonlyArray<NewsInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<NewsOnConflict>;
}

/** aggregate avg on columns */
export interface NewsAvgFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
  readonly content_source_id?: Maybe<Scalars["Float"]["output"]>;
  readonly failed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hash?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "news" */
export interface NewsAvgOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "news". All fields are combined with a logical 'AND'. */
export interface NewsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<NewsBoolExp>>;
  readonly _not?: InputMaybe<NewsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<NewsBoolExp>>;
  readonly author?: InputMaybe<StringComparisonExp>;
  readonly body?: InputMaybe<StringComparisonExp>;
  readonly category?: InputMaybe<CategoriesBoolExp>;
  readonly category_id?: InputMaybe<BigintComparisonExp>;
  readonly company?: InputMaybe<CompaniesBoolExp>;
  readonly company_id?: InputMaybe<UuidComparisonExp>;
  readonly content?: InputMaybe<ContentsBoolExp>;
  readonly content_source?: InputMaybe<ContentSourcesBoolExp>;
  readonly content_source_id?: InputMaybe<BigintComparisonExp>;
  readonly content_status?: InputMaybe<ContentStatusComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly description?: InputMaybe<StringComparisonExp>;
  readonly failed_count?: InputMaybe<SmallintComparisonExp>;
  readonly featured_image?: InputMaybe<StringComparisonExp>;
  readonly has_summary?: InputMaybe<BooleanComparisonExp>;
  readonly hash?: InputMaybe<BigintComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly keywords?: InputMaybe<JsonbComparisonExp>;
  readonly news_summaries?: InputMaybe<NewsSummariesBoolExp>;
  readonly news_summaries_aggregate?: InputMaybe<NewsSummariesAggregateBoolExp>;
  readonly published_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly scrape_frequency?: InputMaybe<ScrapeFrequencyComparisonExp>;
  readonly scraped_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly title?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly url?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "news" */
export type NewsConstraint =
  /** unique or primary key constraint on columns "id" */
  | "news_id_key"
  /** unique or primary key constraint on columns "id" */
  | "news_pkey"
  /** unique or primary key constraint on columns "url" */
  | "news_url_key";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface NewsDeleteAtPathInput {
  readonly keywords?: InputMaybe<ReadonlyArray<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 interface NewsDeleteElemInput {
  readonly keywords?: InputMaybe<Scalars["Int"]["input"]>;
}

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

/** columns and relationships of "news_details" */
export interface NewsDetails {
  readonly author?: Maybe<Scalars["String"]["output"]>;
  readonly bookmark_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly categories?: Maybe<Scalars["jsonb"]["output"]>;
  readonly company_logo?: Maybe<Scalars["String"]["output"]>;
  readonly company_name?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly featured_image?: Maybe<Scalars["String"]["output"]>;
  readonly hot_score?: Maybe<Scalars["float8"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly summaries?: Maybe<Scalars["jsonb"]["output"]>;
  readonly tags?: Maybe<Scalars["jsonb"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly url?: Maybe<Scalars["String"]["output"]>;
  readonly 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 interface NewsDetailsAggregate {
  readonly aggregate?: Maybe<NewsDetailsAggregateFields>;
  readonly nodes: ReadonlyArray<NewsDetails>;
}

/** aggregate fields of "news_details" */
export interface NewsDetailsAggregateFields {
  readonly avg?: Maybe<NewsDetailsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<NewsDetailsMaxFields>;
  readonly min?: Maybe<NewsDetailsMinFields>;
  readonly stddev?: Maybe<NewsDetailsStddevFields>;
  readonly stddev_pop?: Maybe<NewsDetailsStddevPopFields>;
  readonly stddev_samp?: Maybe<NewsDetailsStddevSampFields>;
  readonly sum?: Maybe<NewsDetailsSumFields>;
  readonly var_pop?: Maybe<NewsDetailsVarPopFields>;
  readonly var_samp?: Maybe<NewsDetailsVarSampFields>;
  readonly variance?: Maybe<NewsDetailsVarianceFields>;
}

/** aggregate fields of "news_details" */
export type NewsDetailsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<NewsDetailsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface NewsDetailsAvgFields {
  readonly bookmark_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
  readonly 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 interface NewsDetailsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<NewsDetailsBoolExp>>;
  readonly _not?: InputMaybe<NewsDetailsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<NewsDetailsBoolExp>>;
  readonly author?: InputMaybe<StringComparisonExp>;
  readonly bookmark_count?: InputMaybe<BigintComparisonExp>;
  readonly categories?: InputMaybe<JsonbComparisonExp>;
  readonly company_logo?: InputMaybe<StringComparisonExp>;
  readonly company_name?: InputMaybe<StringComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly description?: InputMaybe<StringComparisonExp>;
  readonly featured_image?: InputMaybe<StringComparisonExp>;
  readonly hot_score?: InputMaybe<Float8ComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly published_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly summaries?: InputMaybe<JsonbComparisonExp>;
  readonly tags?: InputMaybe<JsonbComparisonExp>;
  readonly title?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly url?: InputMaybe<StringComparisonExp>;
  readonly vote_count?: InputMaybe<BigintComparisonExp>;
}

/** aggregate max on columns */
export interface NewsDetailsMaxFields {
  readonly author?: Maybe<Scalars["String"]["output"]>;
  readonly bookmark_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly company_logo?: Maybe<Scalars["String"]["output"]>;
  readonly company_name?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly featured_image?: Maybe<Scalars["String"]["output"]>;
  readonly hot_score?: Maybe<Scalars["float8"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly url?: Maybe<Scalars["String"]["output"]>;
  readonly vote_count?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate min on columns */
export interface NewsDetailsMinFields {
  readonly author?: Maybe<Scalars["String"]["output"]>;
  readonly bookmark_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly company_logo?: Maybe<Scalars["String"]["output"]>;
  readonly company_name?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly featured_image?: Maybe<Scalars["String"]["output"]>;
  readonly hot_score?: Maybe<Scalars["float8"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly url?: Maybe<Scalars["String"]["output"]>;
  readonly vote_count?: Maybe<Scalars["bigint"]["output"]>;
}

/** Ordering options when selecting data from "news_details". */
export interface NewsDetailsOrderBy {
  readonly author?: InputMaybe<OrderBy>;
  readonly bookmark_count?: InputMaybe<OrderBy>;
  readonly categories?: InputMaybe<OrderBy>;
  readonly company_logo?: InputMaybe<OrderBy>;
  readonly company_name?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly description?: InputMaybe<OrderBy>;
  readonly featured_image?: InputMaybe<OrderBy>;
  readonly hot_score?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly published_at?: InputMaybe<OrderBy>;
  readonly summaries?: InputMaybe<OrderBy>;
  readonly tags?: InputMaybe<OrderBy>;
  readonly title?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly url?: InputMaybe<OrderBy>;
  readonly vote_count?: InputMaybe<OrderBy>;
}

/** select columns of table "news_details" */
export type NewsDetailsSelectColumn =
  /** column name */
  | "author"
  /** column name */
  | "bookmark_count"
  /** column name */
  | "categories"
  /** column name */
  | "company_logo"
  /** column name */
  | "company_name"
  /** column name */
  | "created_at"
  /** column name */
  | "description"
  /** column name */
  | "featured_image"
  /** column name */
  | "hot_score"
  /** column name */
  | "id"
  /** column name */
  | "published_at"
  /** column name */
  | "summaries"
  /** column name */
  | "tags"
  /** column name */
  | "title"
  /** column name */
  | "updated_at"
  /** column name */
  | "url"
  /** column name */
  | "vote_count";

/** aggregate stddev on columns */
export interface NewsDetailsStddevFields {
  readonly bookmark_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
  readonly vote_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface NewsDetailsStddevPopFields {
  readonly bookmark_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
  readonly vote_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface NewsDetailsStddevSampFields {
  readonly bookmark_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
  readonly vote_count?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "news_details" */
export interface NewsDetailsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: NewsDetailsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface NewsDetailsStreamCursorValueInput {
  readonly author?: InputMaybe<Scalars["String"]["input"]>;
  readonly bookmark_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly categories?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly company_logo?: InputMaybe<Scalars["String"]["input"]>;
  readonly company_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly featured_image?: InputMaybe<Scalars["String"]["input"]>;
  readonly hot_score?: InputMaybe<Scalars["float8"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly published_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly summaries?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly tags?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly url?: InputMaybe<Scalars["String"]["input"]>;
  readonly vote_count?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** aggregate sum on columns */
export interface NewsDetailsSumFields {
  readonly bookmark_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly hot_score?: Maybe<Scalars["float8"]["output"]>;
  readonly vote_count?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate var_pop on columns */
export interface NewsDetailsVarPopFields {
  readonly bookmark_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
  readonly vote_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface NewsDetailsVarSampFields {
  readonly bookmark_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
  readonly vote_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface NewsDetailsVarianceFields {
  readonly bookmark_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hot_score?: Maybe<Scalars["Float"]["output"]>;
  readonly vote_count?: Maybe<Scalars["Float"]["output"]>;
}

/** input type for incrementing numeric columns in table "news" */
export interface NewsIncInput {
  readonly category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly hash?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** input type for inserting data into table "news" */
export interface NewsInsertInput {
  readonly author?: InputMaybe<Scalars["String"]["input"]>;
  readonly body?: InputMaybe<Scalars["String"]["input"]>;
  readonly category?: InputMaybe<CategoriesObjRelInsertInput>;
  readonly category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly company?: InputMaybe<CompaniesObjRelInsertInput>;
  readonly company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly content?: InputMaybe<ContentsObjRelInsertInput>;
  readonly content_source?: InputMaybe<ContentSourcesObjRelInsertInput>;
  readonly content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly featured_image?: InputMaybe<Scalars["String"]["input"]>;
  readonly has_summary?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly hash?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly keywords?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly news_summaries?: InputMaybe<NewsSummariesArrRelInsertInput>;
  readonly published_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly scrape_frequency?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  readonly scraped_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate max on columns */
export interface NewsMaxFields {
  readonly author?: Maybe<Scalars["String"]["output"]>;
  readonly body?: Maybe<Scalars["String"]["output"]>;
  readonly category_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly company_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly content_status?: Maybe<Scalars["content_status"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly failed_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly featured_image?: Maybe<Scalars["String"]["output"]>;
  readonly hash?: Maybe<Scalars["bigint"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly scrape_frequency?: Maybe<Scalars["scrape_frequency"]["output"]>;
  readonly scraped_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly url?: Maybe<Scalars["String"]["output"]>;
}

/** order by max() on columns of table "news" */
export interface NewsMaxOrderBy {
  readonly author?: InputMaybe<OrderBy>;
  readonly body?: InputMaybe<OrderBy>;
  readonly category_id?: InputMaybe<OrderBy>;
  readonly company_id?: InputMaybe<OrderBy>;
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly content_status?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly description?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly featured_image?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly published_at?: InputMaybe<OrderBy>;
  readonly scrape_frequency?: InputMaybe<OrderBy>;
  readonly scraped_at?: InputMaybe<OrderBy>;
  readonly title?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly url?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface NewsMinFields {
  readonly author?: Maybe<Scalars["String"]["output"]>;
  readonly body?: Maybe<Scalars["String"]["output"]>;
  readonly category_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly company_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly content_status?: Maybe<Scalars["content_status"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly failed_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly featured_image?: Maybe<Scalars["String"]["output"]>;
  readonly hash?: Maybe<Scalars["bigint"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly scrape_frequency?: Maybe<Scalars["scrape_frequency"]["output"]>;
  readonly scraped_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly url?: Maybe<Scalars["String"]["output"]>;
}

/** order by min() on columns of table "news" */
export interface NewsMinOrderBy {
  readonly author?: InputMaybe<OrderBy>;
  readonly body?: InputMaybe<OrderBy>;
  readonly category_id?: InputMaybe<OrderBy>;
  readonly company_id?: InputMaybe<OrderBy>;
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly content_status?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly description?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly featured_image?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly published_at?: InputMaybe<OrderBy>;
  readonly scrape_frequency?: InputMaybe<OrderBy>;
  readonly scraped_at?: InputMaybe<OrderBy>;
  readonly title?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly url?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "news" */
export interface NewsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<News>;
}

/** input type for inserting object relation for remote table "news" */
export interface NewsObjRelInsertInput {
  readonly data: NewsInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<NewsOnConflict>;
}

/** on_conflict condition type for table "news" */
export interface NewsOnConflict {
  readonly constraint: NewsConstraint;
  readonly update_columns: ReadonlyArray<NewsUpdateColumn>;
  readonly where?: InputMaybe<NewsBoolExp>;
}

/** Ordering options when selecting data from "news". */
export interface NewsOrderBy {
  readonly author?: InputMaybe<OrderBy>;
  readonly body?: InputMaybe<OrderBy>;
  readonly category?: InputMaybe<CategoriesOrderBy>;
  readonly category_id?: InputMaybe<OrderBy>;
  readonly company?: InputMaybe<CompaniesOrderBy>;
  readonly company_id?: InputMaybe<OrderBy>;
  readonly content?: InputMaybe<ContentsOrderBy>;
  readonly content_source?: InputMaybe<ContentSourcesOrderBy>;
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly content_status?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly description?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly featured_image?: InputMaybe<OrderBy>;
  readonly has_summary?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly keywords?: InputMaybe<OrderBy>;
  readonly news_summaries_aggregate?: InputMaybe<NewsSummariesAggregateOrderBy>;
  readonly published_at?: InputMaybe<OrderBy>;
  readonly scrape_frequency?: InputMaybe<OrderBy>;
  readonly scraped_at?: InputMaybe<OrderBy>;
  readonly title?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly url?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: news */
export interface NewsPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

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

/** select columns of table "news" */
export type NewsSelectColumn =
  /** column name */
  | "author"
  /** column name */
  | "body"
  /** column name */
  | "category_id"
  /** column name */
  | "company_id"
  /** column name */
  | "content_source_id"
  /** column name */
  | "content_status"
  /** column name */
  | "created_at"
  /** column name */
  | "description"
  /** column name */
  | "failed_count"
  /** column name */
  | "featured_image"
  /** column name */
  | "has_summary"
  /** column name */
  | "hash"
  /** column name */
  | "id"
  /** column name */
  | "keywords"
  /** column name */
  | "published_at"
  /** column name */
  | "scrape_frequency"
  /** column name */
  | "scraped_at"
  /** column name */
  | "title"
  /** column name */
  | "updated_at"
  /** column name */
  | "url";

/** select "news_aggregate_bool_exp_bool_and_arguments_columns" columns of table "news" */
export type NewsSelectColumnNewsAggregateBoolExpBoolAndArgumentsColumns =
  /** column name */
  "has_summary";

/** select "news_aggregate_bool_exp_bool_or_arguments_columns" columns of table "news" */
export type NewsSelectColumnNewsAggregateBoolExpBoolOrArgumentsColumns =
  /** column name */
  "has_summary";

/** input type for updating data in table "news" */
export interface NewsSetInput {
  readonly author?: InputMaybe<Scalars["String"]["input"]>;
  readonly body?: InputMaybe<Scalars["String"]["input"]>;
  readonly category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly featured_image?: InputMaybe<Scalars["String"]["input"]>;
  readonly has_summary?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly hash?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly keywords?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly published_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly scrape_frequency?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  readonly scraped_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate stddev on columns */
export interface NewsStddevFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
  readonly content_source_id?: Maybe<Scalars["Float"]["output"]>;
  readonly failed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hash?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "news" */
export interface NewsStddevOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface NewsStddevPopFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
  readonly content_source_id?: Maybe<Scalars["Float"]["output"]>;
  readonly failed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hash?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "news" */
export interface NewsStddevPopOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface NewsStddevSampFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
  readonly content_source_id?: Maybe<Scalars["Float"]["output"]>;
  readonly failed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hash?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "news" */
export interface NewsStddevSampOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "news" */
export interface NewsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: NewsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface NewsStreamCursorValueInput {
  readonly author?: InputMaybe<Scalars["String"]["input"]>;
  readonly body?: InputMaybe<Scalars["String"]["input"]>;
  readonly category_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly company_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly content_source_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly failed_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly featured_image?: InputMaybe<Scalars["String"]["input"]>;
  readonly has_summary?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly hash?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly keywords?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly published_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly scrape_frequency?: InputMaybe<Scalars["scrape_frequency"]["input"]>;
  readonly scraped_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface NewsSumFields {
  readonly category_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly content_source_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly failed_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly hash?: Maybe<Scalars["bigint"]["output"]>;
}

/** order by sum() on columns of table "news" */
export interface NewsSumOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
}

/** columns and relationships of "news_summaries" */
export interface NewsSummaries {
  readonly complexity_level?: Maybe<Scalars["complexity_level"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly embedding?: Maybe<Scalars["vector"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  readonly is_current?: Maybe<Scalars["Boolean"]["output"]>;
  /** An object relationship */
  readonly news: News;
  readonly news_id: Scalars["uuid"]["output"];
  readonly summary?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly version: Scalars["Int"]["output"];
}

/** aggregated selection of "news_summaries" */
export interface NewsSummariesAggregate {
  readonly aggregate?: Maybe<NewsSummariesAggregateFields>;
  readonly nodes: ReadonlyArray<NewsSummaries>;
}

export interface NewsSummariesAggregateBoolExp {
  readonly bool_and?: InputMaybe<NewsSummariesAggregateBoolExpBoolAnd>;
  readonly bool_or?: InputMaybe<NewsSummariesAggregateBoolExpBoolOr>;
  readonly count?: InputMaybe<NewsSummariesAggregateBoolExpCount>;
}

export interface NewsSummariesAggregateBoolExpBoolAnd {
  readonly arguments: NewsSummariesSelectColumnNewsSummariesAggregateBoolExpBoolAndArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<NewsSummariesBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface NewsSummariesAggregateBoolExpBoolOr {
  readonly arguments: NewsSummariesSelectColumnNewsSummariesAggregateBoolExpBoolOrArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<NewsSummariesBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface NewsSummariesAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<NewsSummariesSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<NewsSummariesBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "news_summaries" */
export interface NewsSummariesAggregateFields {
  readonly avg?: Maybe<NewsSummariesAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<NewsSummariesMaxFields>;
  readonly min?: Maybe<NewsSummariesMinFields>;
  readonly stddev?: Maybe<NewsSummariesStddevFields>;
  readonly stddev_pop?: Maybe<NewsSummariesStddevPopFields>;
  readonly stddev_samp?: Maybe<NewsSummariesStddevSampFields>;
  readonly sum?: Maybe<NewsSummariesSumFields>;
  readonly var_pop?: Maybe<NewsSummariesVarPopFields>;
  readonly var_samp?: Maybe<NewsSummariesVarSampFields>;
  readonly variance?: Maybe<NewsSummariesVarianceFields>;
}

/** aggregate fields of "news_summaries" */
export type NewsSummariesAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<NewsSummariesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "news_summaries" */
export interface NewsSummariesAggregateOrderBy {
  readonly avg?: InputMaybe<NewsSummariesAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<NewsSummariesMaxOrderBy>;
  readonly min?: InputMaybe<NewsSummariesMinOrderBy>;
  readonly stddev?: InputMaybe<NewsSummariesStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<NewsSummariesStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<NewsSummariesStddevSampOrderBy>;
  readonly sum?: InputMaybe<NewsSummariesSumOrderBy>;
  readonly var_pop?: InputMaybe<NewsSummariesVarPopOrderBy>;
  readonly var_samp?: InputMaybe<NewsSummariesVarSampOrderBy>;
  readonly variance?: InputMaybe<NewsSummariesVarianceOrderBy>;
}

/** input type for inserting array relation for remote table "news_summaries" */
export interface NewsSummariesArrRelInsertInput {
  readonly data: ReadonlyArray<NewsSummariesInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<NewsSummariesOnConflict>;
}

/** aggregate avg on columns */
export interface NewsSummariesAvgFields {
  readonly version?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "news_summaries" */
export interface NewsSummariesAvgOrderBy {
  readonly version?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "news_summaries". All fields are combined with a logical 'AND'. */
export interface NewsSummariesBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<NewsSummariesBoolExp>>;
  readonly _not?: InputMaybe<NewsSummariesBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<NewsSummariesBoolExp>>;
  readonly complexity_level?: InputMaybe<ComplexityLevelComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly embedding?: InputMaybe<VectorComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly is_current?: InputMaybe<BooleanComparisonExp>;
  readonly news?: InputMaybe<NewsBoolExp>;
  readonly news_id?: InputMaybe<UuidComparisonExp>;
  readonly summary?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly version?: InputMaybe<IntComparisonExp>;
}

/** unique or primary key constraints on table "news_summaries" */
export type NewsSummariesConstraint =
  /** unique or primary key constraint on columns "id" */
  "news_summaries_pkey";

/** input type for incrementing numeric columns in table "news_summaries" */
export interface NewsSummariesIncInput {
  readonly version?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "news_summaries" */
export interface NewsSummariesInsertInput {
  readonly complexity_level?: InputMaybe<Scalars["complexity_level"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly embedding?: InputMaybe<Scalars["vector"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly is_current?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly news?: InputMaybe<NewsObjRelInsertInput>;
  readonly news_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly summary?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly version?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate max on columns */
export interface NewsSummariesMaxFields {
  readonly complexity_level?: Maybe<Scalars["complexity_level"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly news_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly summary?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly version?: Maybe<Scalars["Int"]["output"]>;
}

/** order by max() on columns of table "news_summaries" */
export interface NewsSummariesMaxOrderBy {
  readonly complexity_level?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly news_id?: InputMaybe<OrderBy>;
  readonly summary?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly version?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface NewsSummariesMinFields {
  readonly complexity_level?: Maybe<Scalars["complexity_level"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly news_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly summary?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly version?: Maybe<Scalars["Int"]["output"]>;
}

/** order by min() on columns of table "news_summaries" */
export interface NewsSummariesMinOrderBy {
  readonly complexity_level?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly news_id?: InputMaybe<OrderBy>;
  readonly summary?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly version?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "news_summaries" */
export interface NewsSummariesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<NewsSummaries>;
}

/** on_conflict condition type for table "news_summaries" */
export interface NewsSummariesOnConflict {
  readonly constraint: NewsSummariesConstraint;
  readonly update_columns: ReadonlyArray<NewsSummariesUpdateColumn>;
  readonly where?: InputMaybe<NewsSummariesBoolExp>;
}

/** Ordering options when selecting data from "news_summaries". */
export interface NewsSummariesOrderBy {
  readonly complexity_level?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly embedding?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly is_current?: InputMaybe<OrderBy>;
  readonly news?: InputMaybe<NewsOrderBy>;
  readonly news_id?: InputMaybe<OrderBy>;
  readonly summary?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly version?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: news_summaries */
export interface NewsSummariesPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** select columns of table "news_summaries" */
export type NewsSummariesSelectColumn =
  /** column name */
  | "complexity_level"
  /** column name */
  | "created_at"
  /** column name */
  | "embedding"
  /** column name */
  | "id"
  /** column name */
  | "is_current"
  /** column name */
  | "news_id"
  /** column name */
  | "summary"
  /** column name */
  | "updated_at"
  /** column name */
  | "version";

/** select "news_summaries_aggregate_bool_exp_bool_and_arguments_columns" columns of table "news_summaries" */
export type NewsSummariesSelectColumnNewsSummariesAggregateBoolExpBoolAndArgumentsColumns =
  /** column name */
  "is_current";

/** select "news_summaries_aggregate_bool_exp_bool_or_arguments_columns" columns of table "news_summaries" */
export type NewsSummariesSelectColumnNewsSummariesAggregateBoolExpBoolOrArgumentsColumns =
  /** column name */
  "is_current";

/** input type for updating data in table "news_summaries" */
export interface NewsSummariesSetInput {
  readonly complexity_level?: InputMaybe<Scalars["complexity_level"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly embedding?: InputMaybe<Scalars["vector"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly is_current?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly news_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly summary?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly version?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate stddev on columns */
export interface NewsSummariesStddevFields {
  readonly version?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "news_summaries" */
export interface NewsSummariesStddevOrderBy {
  readonly version?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface NewsSummariesStddevPopFields {
  readonly version?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "news_summaries" */
export interface NewsSummariesStddevPopOrderBy {
  readonly version?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface NewsSummariesStddevSampFields {
  readonly version?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "news_summaries" */
export interface NewsSummariesStddevSampOrderBy {
  readonly version?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "news_summaries" */
export interface NewsSummariesStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: NewsSummariesStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface NewsSummariesStreamCursorValueInput {
  readonly complexity_level?: InputMaybe<Scalars["complexity_level"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly embedding?: InputMaybe<Scalars["vector"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly is_current?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly news_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly summary?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly version?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate sum on columns */
export interface NewsSummariesSumFields {
  readonly version?: Maybe<Scalars["Int"]["output"]>;
}

/** order by sum() on columns of table "news_summaries" */
export interface NewsSummariesSumOrderBy {
  readonly version?: InputMaybe<OrderBy>;
}

/** update columns of table "news_summaries" */
export type NewsSummariesUpdateColumn =
  /** column name */
  | "complexity_level"
  /** column name */
  | "created_at"
  /** column name */
  | "embedding"
  /** column name */
  | "id"
  /** column name */
  | "is_current"
  /** column name */
  | "news_id"
  /** column name */
  | "summary"
  /** column name */
  | "updated_at"
  /** column name */
  | "version";

export interface NewsSummariesUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<NewsSummariesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<NewsSummariesSetInput>;
  /** filter the rows which have to be updated */
  readonly where: NewsSummariesBoolExp;
}

/** aggregate var_pop on columns */
export interface NewsSummariesVarPopFields {
  readonly version?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "news_summaries" */
export interface NewsSummariesVarPopOrderBy {
  readonly version?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface NewsSummariesVarSampFields {
  readonly version?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "news_summaries" */
export interface NewsSummariesVarSampOrderBy {
  readonly version?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface NewsSummariesVarianceFields {
  readonly version?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "news_summaries" */
export interface NewsSummariesVarianceOrderBy {
  readonly version?: InputMaybe<OrderBy>;
}

/** columns and relationships of "news_tags" */
export interface NewsTags {
  readonly id: Scalars["Int"]["output"];
  readonly news_id?: Maybe<Scalars["uuid"]["output"]>;
  /** An object relationship */
  readonly tag: Tags;
  readonly tag_id: Scalars["Int"]["output"];
}

/** aggregated selection of "news_tags" */
export interface NewsTagsAggregate {
  readonly aggregate?: Maybe<NewsTagsAggregateFields>;
  readonly nodes: ReadonlyArray<NewsTags>;
}

export interface NewsTagsAggregateBoolExp {
  readonly count?: InputMaybe<NewsTagsAggregateBoolExpCount>;
}

export interface NewsTagsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<NewsTagsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<NewsTagsBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "news_tags" */
export interface NewsTagsAggregateFields {
  readonly avg?: Maybe<NewsTagsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<NewsTagsMaxFields>;
  readonly min?: Maybe<NewsTagsMinFields>;
  readonly stddev?: Maybe<NewsTagsStddevFields>;
  readonly stddev_pop?: Maybe<NewsTagsStddevPopFields>;
  readonly stddev_samp?: Maybe<NewsTagsStddevSampFields>;
  readonly sum?: Maybe<NewsTagsSumFields>;
  readonly var_pop?: Maybe<NewsTagsVarPopFields>;
  readonly var_samp?: Maybe<NewsTagsVarSampFields>;
  readonly variance?: Maybe<NewsTagsVarianceFields>;
}

/** aggregate fields of "news_tags" */
export type NewsTagsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<NewsTagsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "news_tags" */
export interface NewsTagsAggregateOrderBy {
  readonly avg?: InputMaybe<NewsTagsAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<NewsTagsMaxOrderBy>;
  readonly min?: InputMaybe<NewsTagsMinOrderBy>;
  readonly stddev?: InputMaybe<NewsTagsStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<NewsTagsStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<NewsTagsStddevSampOrderBy>;
  readonly sum?: InputMaybe<NewsTagsSumOrderBy>;
  readonly var_pop?: InputMaybe<NewsTagsVarPopOrderBy>;
  readonly var_samp?: InputMaybe<NewsTagsVarSampOrderBy>;
  readonly variance?: InputMaybe<NewsTagsVarianceOrderBy>;
}

/** input type for inserting array relation for remote table "news_tags" */
export interface NewsTagsArrRelInsertInput {
  readonly data: ReadonlyArray<NewsTagsInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<NewsTagsOnConflict>;
}

/** aggregate avg on columns */
export interface NewsTagsAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly tag_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "news_tags" */
export interface NewsTagsAvgOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "news_tags". All fields are combined with a logical 'AND'. */
export interface NewsTagsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<NewsTagsBoolExp>>;
  readonly _not?: InputMaybe<NewsTagsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<NewsTagsBoolExp>>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly news_id?: InputMaybe<UuidComparisonExp>;
  readonly tag?: InputMaybe<TagsBoolExp>;
  readonly tag_id?: InputMaybe<IntComparisonExp>;
}

/** unique or primary key constraints on table "news_tags" */
export type NewsTagsConstraint =
  /** unique or primary key constraint on columns "id" */
  "news_tags_pkey";

/** input type for incrementing numeric columns in table "news_tags" */
export interface NewsTagsIncInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly tag_id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "news_tags" */
export interface NewsTagsInsertInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly news_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly tag?: InputMaybe<TagsObjRelInsertInput>;
  readonly tag_id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate max on columns */
export interface NewsTagsMaxFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly news_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly tag_id?: Maybe<Scalars["Int"]["output"]>;
}

/** order by max() on columns of table "news_tags" */
export interface NewsTagsMaxOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly news_id?: InputMaybe<OrderBy>;
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface NewsTagsMinFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly news_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly tag_id?: Maybe<Scalars["Int"]["output"]>;
}

/** order by min() on columns of table "news_tags" */
export interface NewsTagsMinOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly news_id?: InputMaybe<OrderBy>;
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "news_tags" */
export interface NewsTagsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<NewsTags>;
}

/** on_conflict condition type for table "news_tags" */
export interface NewsTagsOnConflict {
  readonly constraint: NewsTagsConstraint;
  readonly update_columns: ReadonlyArray<NewsTagsUpdateColumn>;
  readonly where?: InputMaybe<NewsTagsBoolExp>;
}

/** Ordering options when selecting data from "news_tags". */
export interface NewsTagsOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly news_id?: InputMaybe<OrderBy>;
  readonly tag?: InputMaybe<TagsOrderBy>;
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: news_tags */
export interface NewsTagsPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** select columns of table "news_tags" */
export type NewsTagsSelectColumn =
  /** column name */
  | "id"
  /** column name */
  | "news_id"
  /** column name */
  | "tag_id";

/** input type for updating data in table "news_tags" */
export interface NewsTagsSetInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly news_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly tag_id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate stddev on columns */
export interface NewsTagsStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly tag_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "news_tags" */
export interface NewsTagsStddevOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface NewsTagsStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly tag_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "news_tags" */
export interface NewsTagsStddevPopOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface NewsTagsStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly tag_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "news_tags" */
export interface NewsTagsStddevSampOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "news_tags" */
export interface NewsTagsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: NewsTagsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface NewsTagsStreamCursorValueInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly news_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly tag_id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate sum on columns */
export interface NewsTagsSumFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly tag_id?: Maybe<Scalars["Int"]["output"]>;
}

/** order by sum() on columns of table "news_tags" */
export interface NewsTagsSumOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** update columns of table "news_tags" */
export type NewsTagsUpdateColumn =
  /** column name */
  | "id"
  /** column name */
  | "news_id"
  /** column name */
  | "tag_id";

export interface NewsTagsUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<NewsTagsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<NewsTagsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: NewsTagsBoolExp;
}

/** aggregate var_pop on columns */
export interface NewsTagsVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly tag_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "news_tags" */
export interface NewsTagsVarPopOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface NewsTagsVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly tag_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "news_tags" */
export interface NewsTagsVarSampOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface NewsTagsVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly tag_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "news_tags" */
export interface NewsTagsVarianceOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly tag_id?: InputMaybe<OrderBy>;
}

/** update columns of table "news" */
export type NewsUpdateColumn =
  /** column name */
  | "author"
  /** column name */
  | "body"
  /** column name */
  | "category_id"
  /** column name */
  | "company_id"
  /** column name */
  | "content_source_id"
  /** column name */
  | "content_status"
  /** column name */
  | "created_at"
  /** column name */
  | "description"
  /** column name */
  | "failed_count"
  /** column name */
  | "featured_image"
  /** column name */
  | "has_summary"
  /** column name */
  | "hash"
  /** column name */
  | "id"
  /** column name */
  | "keywords"
  /** column name */
  | "published_at"
  /** column name */
  | "scrape_frequency"
  /** column name */
  | "scraped_at"
  /** column name */
  | "title"
  /** column name */
  | "updated_at"
  /** column name */
  | "url";

export interface NewsUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<NewsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<NewsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<NewsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<NewsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<NewsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<NewsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: NewsBoolExp;
}

/** aggregate var_pop on columns */
export interface NewsVarPopFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
  readonly content_source_id?: Maybe<Scalars["Float"]["output"]>;
  readonly failed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hash?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "news" */
export interface NewsVarPopOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface NewsVarSampFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
  readonly content_source_id?: Maybe<Scalars["Float"]["output"]>;
  readonly failed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hash?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "news" */
export interface NewsVarSampOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface NewsVarianceFields {
  readonly category_id?: Maybe<Scalars["Float"]["output"]>;
  readonly content_source_id?: Maybe<Scalars["Float"]["output"]>;
  readonly failed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly hash?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "news" */
export interface NewsVarianceOrderBy {
  readonly category_id?: InputMaybe<OrderBy>;
  readonly content_source_id?: InputMaybe<OrderBy>;
  readonly failed_count?: InputMaybe<OrderBy>;
  readonly hash?: InputMaybe<OrderBy>;
}

/** columns and relationships of "newsletters" */
export interface Newsletters {
  /** An object relationship */
  readonly content: Contents;
  readonly content_status: Scalars["content_status"]["output"];
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly end_date: Scalars["timestamptz"]["output"];
  readonly frequency: Scalars["String"]["output"];
  readonly generated_content?: Maybe<Scalars["String"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  readonly start_date: Scalars["timestamptz"]["output"];
  readonly title: Scalars["String"]["output"];
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** aggregated selection of "newsletters" */
export interface NewslettersAggregate {
  readonly aggregate?: Maybe<NewslettersAggregateFields>;
  readonly nodes: ReadonlyArray<Newsletters>;
}

/** aggregate fields of "newsletters" */
export interface NewslettersAggregateFields {
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<NewslettersMaxFields>;
  readonly min?: Maybe<NewslettersMinFields>;
}

/** aggregate fields of "newsletters" */
export type NewslettersAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<NewslettersSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** Boolean expression to filter rows from the table "newsletters". All fields are combined with a logical 'AND'. */
export interface NewslettersBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<NewslettersBoolExp>>;
  readonly _not?: InputMaybe<NewslettersBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<NewslettersBoolExp>>;
  readonly content?: InputMaybe<ContentsBoolExp>;
  readonly content_status?: InputMaybe<ContentStatusComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly end_date?: InputMaybe<TimestamptzComparisonExp>;
  readonly frequency?: InputMaybe<StringComparisonExp>;
  readonly generated_content?: InputMaybe<StringComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly start_date?: InputMaybe<TimestamptzComparisonExp>;
  readonly title?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
}

/** unique or primary key constraints on table "newsletters" */
export type NewslettersConstraint =
  /** unique or primary key constraint on columns "id" */
  "newsletters_pkey";

/** input type for inserting data into table "newsletters" */
export interface NewslettersInsertInput {
  readonly content?: InputMaybe<ContentsObjRelInsertInput>;
  readonly content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly end_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly frequency?: InputMaybe<Scalars["String"]["input"]>;
  readonly generated_content?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly start_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate max on columns */
export interface NewslettersMaxFields {
  readonly content_status?: Maybe<Scalars["content_status"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly end_date?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly frequency?: Maybe<Scalars["String"]["output"]>;
  readonly generated_content?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly start_date?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** aggregate min on columns */
export interface NewslettersMinFields {
  readonly content_status?: Maybe<Scalars["content_status"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly end_date?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly frequency?: Maybe<Scalars["String"]["output"]>;
  readonly generated_content?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly start_date?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** response of any mutation on the table "newsletters" */
export interface NewslettersMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Newsletters>;
}

/** input type for inserting object relation for remote table "newsletters" */
export interface NewslettersObjRelInsertInput {
  readonly data: NewslettersInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<NewslettersOnConflict>;
}

/** on_conflict condition type for table "newsletters" */
export interface NewslettersOnConflict {
  readonly constraint: NewslettersConstraint;
  readonly update_columns: ReadonlyArray<NewslettersUpdateColumn>;
  readonly where?: InputMaybe<NewslettersBoolExp>;
}

/** Ordering options when selecting data from "newsletters". */
export interface NewslettersOrderBy {
  readonly content?: InputMaybe<ContentsOrderBy>;
  readonly content_status?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly end_date?: InputMaybe<OrderBy>;
  readonly frequency?: InputMaybe<OrderBy>;
  readonly generated_content?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly start_date?: InputMaybe<OrderBy>;
  readonly title?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: newsletters */
export interface NewslettersPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** select columns of table "newsletters" */
export type NewslettersSelectColumn =
  /** column name */
  | "content_status"
  /** column name */
  | "created_at"
  /** column name */
  | "end_date"
  /** column name */
  | "frequency"
  /** column name */
  | "generated_content"
  /** column name */
  | "id"
  /** column name */
  | "start_date"
  /** column name */
  | "title"
  /** column name */
  | "updated_at";

/** input type for updating data in table "newsletters" */
export interface NewslettersSetInput {
  readonly content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly end_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly frequency?: InputMaybe<Scalars["String"]["input"]>;
  readonly generated_content?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly start_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** Streaming cursor of the table "newsletters" */
export interface NewslettersStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: NewslettersStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface NewslettersStreamCursorValueInput {
  readonly content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly end_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly frequency?: InputMaybe<Scalars["String"]["input"]>;
  readonly generated_content?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly start_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** update columns of table "newsletters" */
export type NewslettersUpdateColumn =
  /** column name */
  | "content_status"
  /** column name */
  | "created_at"
  /** column name */
  | "end_date"
  /** column name */
  | "frequency"
  /** column name */
  | "generated_content"
  /** column name */
  | "id"
  /** column name */
  | "start_date"
  /** column name */
  | "title"
  /** column name */
  | "updated_at";

export interface NewslettersUpdates {
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<NewslettersSetInput>;
  /** filter the rows which have to be updated */
  readonly where: NewslettersBoolExp;
}

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

/** column ordering options */
export type OrderBy =
  /** in ascending order, nulls last */
  | "asc"
  /** in ascending order, nulls first */
  | "asc_nulls_first"
  /** in ascending order, nulls last */
  | "asc_nulls_last"
  /** in descending order, nulls first */
  | "desc"
  /** in descending order, nulls first */
  | "desc_nulls_first"
  /** in descending order, nulls last */
  | "desc_nulls_last";

/** columns and relationships of "payment_providers" */
export interface PaymentProviders {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  /** An array relationship */
  readonly customer_payments: ReadonlyArray<CustomerPayments>;
  /** An aggregate relationship */
  readonly customer_payments_aggregate: CustomerPaymentsAggregate;
  /** An array relationship */
  readonly customer_subscriptions: ReadonlyArray<CustomerSubscriptions>;
  /** An aggregate relationship */
  readonly customer_subscriptions_aggregate: CustomerSubscriptionsAggregate;
  readonly id: Scalars["Int"]["output"];
  readonly is_active?: Maybe<Scalars["Boolean"]["output"]>;
  readonly name: Scalars["String"]["output"];
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** columns and relationships of "payment_providers" */
export type PaymentProvidersCustomerPaymentsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

/** columns and relationships of "payment_providers" */
export type PaymentProvidersCustomerPaymentsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

/** columns and relationships of "payment_providers" */
export type PaymentProvidersCustomerSubscriptionsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

/** columns and relationships of "payment_providers" */
export type PaymentProvidersCustomerSubscriptionsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

/** aggregated selection of "payment_providers" */
export interface PaymentProvidersAggregate {
  readonly aggregate?: Maybe<PaymentProvidersAggregateFields>;
  readonly nodes: ReadonlyArray<PaymentProviders>;
}

/** aggregate fields of "payment_providers" */
export interface PaymentProvidersAggregateFields {
  readonly avg?: Maybe<PaymentProvidersAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<PaymentProvidersMaxFields>;
  readonly min?: Maybe<PaymentProvidersMinFields>;
  readonly stddev?: Maybe<PaymentProvidersStddevFields>;
  readonly stddev_pop?: Maybe<PaymentProvidersStddevPopFields>;
  readonly stddev_samp?: Maybe<PaymentProvidersStddevSampFields>;
  readonly sum?: Maybe<PaymentProvidersSumFields>;
  readonly var_pop?: Maybe<PaymentProvidersVarPopFields>;
  readonly var_samp?: Maybe<PaymentProvidersVarSampFields>;
  readonly variance?: Maybe<PaymentProvidersVarianceFields>;
}

/** aggregate fields of "payment_providers" */
export type PaymentProvidersAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<PaymentProvidersSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface PaymentProvidersAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "payment_providers". All fields are combined with a logical 'AND'. */
export interface PaymentProvidersBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<PaymentProvidersBoolExp>>;
  readonly _not?: InputMaybe<PaymentProvidersBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<PaymentProvidersBoolExp>>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly customer_payments?: InputMaybe<CustomerPaymentsBoolExp>;
  readonly customer_payments_aggregate?: InputMaybe<CustomerPaymentsAggregateBoolExp>;
  readonly customer_subscriptions?: InputMaybe<CustomerSubscriptionsBoolExp>;
  readonly customer_subscriptions_aggregate?: InputMaybe<CustomerSubscriptionsAggregateBoolExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly is_active?: InputMaybe<BooleanComparisonExp>;
  readonly name?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
}

/** unique or primary key constraints on table "payment_providers" */
export type PaymentProvidersConstraint =
  /** unique or primary key constraint on columns "name" */
  | "payment_providers_name_key"
  /** unique or primary key constraint on columns "id" */
  | "payment_providers_pkey";

/** input type for incrementing numeric columns in table "payment_providers" */
export interface PaymentProvidersIncInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "payment_providers" */
export interface PaymentProvidersInsertInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly customer_payments?: InputMaybe<CustomerPaymentsArrRelInsertInput>;
  readonly customer_subscriptions?: InputMaybe<CustomerSubscriptionsArrRelInsertInput>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate max on columns */
export interface PaymentProvidersMaxFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** aggregate min on columns */
export interface PaymentProvidersMinFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** response of any mutation on the table "payment_providers" */
export interface PaymentProvidersMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<PaymentProviders>;
}

/** input type for inserting object relation for remote table "payment_providers" */
export interface PaymentProvidersObjRelInsertInput {
  readonly data: PaymentProvidersInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<PaymentProvidersOnConflict>;
}

/** on_conflict condition type for table "payment_providers" */
export interface PaymentProvidersOnConflict {
  readonly constraint: PaymentProvidersConstraint;
  readonly update_columns: ReadonlyArray<PaymentProvidersUpdateColumn>;
  readonly where?: InputMaybe<PaymentProvidersBoolExp>;
}

/** Ordering options when selecting data from "payment_providers". */
export interface PaymentProvidersOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly customer_payments_aggregate?: InputMaybe<CustomerPaymentsAggregateOrderBy>;
  readonly customer_subscriptions_aggregate?: InputMaybe<CustomerSubscriptionsAggregateOrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly is_active?: InputMaybe<OrderBy>;
  readonly name?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: payment_providers */
export interface PaymentProvidersPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** select columns of table "payment_providers" */
export type PaymentProvidersSelectColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "is_active"
  /** column name */
  | "name"
  /** column name */
  | "updated_at";

/** input type for updating data in table "payment_providers" */
export interface PaymentProvidersSetInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate stddev on columns */
export interface PaymentProvidersStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface PaymentProvidersStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface PaymentProvidersStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "payment_providers" */
export interface PaymentProvidersStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: PaymentProvidersStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface PaymentProvidersStreamCursorValueInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate sum on columns */
export interface PaymentProvidersSumFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "payment_providers" */
export type PaymentProvidersUpdateColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "is_active"
  /** column name */
  | "name"
  /** column name */
  | "updated_at";

export interface PaymentProvidersUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<PaymentProvidersIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<PaymentProvidersSetInput>;
  /** filter the rows which have to be updated */
  readonly where: PaymentProvidersBoolExp;
}

/** aggregate var_pop on columns */
export interface PaymentProvidersVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface PaymentProvidersVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface PaymentProvidersVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "plan_permissions" */
export interface PlanPermissions {
  readonly feature: Scalars["String"]["output"];
  readonly id: Scalars["Int"]["output"];
  readonly plan: Scalars["app_plan_enum"]["output"];
}

/** aggregated selection of "plan_permissions" */
export interface PlanPermissionsAggregate {
  readonly aggregate?: Maybe<PlanPermissionsAggregateFields>;
  readonly nodes: ReadonlyArray<PlanPermissions>;
}

/** aggregate fields of "plan_permissions" */
export interface PlanPermissionsAggregateFields {
  readonly avg?: Maybe<PlanPermissionsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<PlanPermissionsMaxFields>;
  readonly min?: Maybe<PlanPermissionsMinFields>;
  readonly stddev?: Maybe<PlanPermissionsStddevFields>;
  readonly stddev_pop?: Maybe<PlanPermissionsStddevPopFields>;
  readonly stddev_samp?: Maybe<PlanPermissionsStddevSampFields>;
  readonly sum?: Maybe<PlanPermissionsSumFields>;
  readonly var_pop?: Maybe<PlanPermissionsVarPopFields>;
  readonly var_samp?: Maybe<PlanPermissionsVarSampFields>;
  readonly variance?: Maybe<PlanPermissionsVarianceFields>;
}

/** aggregate fields of "plan_permissions" */
export type PlanPermissionsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<PlanPermissionsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface PlanPermissionsAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "plan_permissions". All fields are combined with a logical 'AND'. */
export interface PlanPermissionsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<PlanPermissionsBoolExp>>;
  readonly _not?: InputMaybe<PlanPermissionsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<PlanPermissionsBoolExp>>;
  readonly feature?: InputMaybe<StringComparisonExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly plan?: InputMaybe<AppPlanEnumComparisonExp>;
}

/** unique or primary key constraints on table "plan_permissions" */
export type PlanPermissionsConstraint =
  /** unique or primary key constraint on columns "id" */
  "plan_permissions_pkey";

/** input type for incrementing numeric columns in table "plan_permissions" */
export interface PlanPermissionsIncInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "plan_permissions" */
export interface PlanPermissionsInsertInput {
  readonly feature?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly plan?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
}

/** aggregate max on columns */
export interface PlanPermissionsMaxFields {
  readonly feature?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly plan?: Maybe<Scalars["app_plan_enum"]["output"]>;
}

/** aggregate min on columns */
export interface PlanPermissionsMinFields {
  readonly feature?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly plan?: Maybe<Scalars["app_plan_enum"]["output"]>;
}

/** response of any mutation on the table "plan_permissions" */
export interface PlanPermissionsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<PlanPermissions>;
}

/** on_conflict condition type for table "plan_permissions" */
export interface PlanPermissionsOnConflict {
  readonly constraint: PlanPermissionsConstraint;
  readonly update_columns: ReadonlyArray<PlanPermissionsUpdateColumn>;
  readonly where?: InputMaybe<PlanPermissionsBoolExp>;
}

/** Ordering options when selecting data from "plan_permissions". */
export interface PlanPermissionsOrderBy {
  readonly feature?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly plan?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: plan_permissions */
export interface PlanPermissionsPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** select columns of table "plan_permissions" */
export type PlanPermissionsSelectColumn =
  /** column name */
  | "feature"
  /** column name */
  | "id"
  /** column name */
  | "plan";

/** input type for updating data in table "plan_permissions" */
export interface PlanPermissionsSetInput {
  readonly feature?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly plan?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
}

/** aggregate stddev on columns */
export interface PlanPermissionsStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface PlanPermissionsStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface PlanPermissionsStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "plan_permissions" */
export interface PlanPermissionsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: PlanPermissionsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface PlanPermissionsStreamCursorValueInput {
  readonly feature?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly plan?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
}

/** aggregate sum on columns */
export interface PlanPermissionsSumFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "plan_permissions" */
export type PlanPermissionsUpdateColumn =
  /** column name */
  | "feature"
  /** column name */
  | "id"
  /** column name */
  | "plan";

export interface PlanPermissionsUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<PlanPermissionsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<PlanPermissionsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: PlanPermissionsBoolExp;
}

/** aggregate var_pop on columns */
export interface PlanPermissionsVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface PlanPermissionsVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface PlanPermissionsVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

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

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

export interface QueryRoot {
  /** An array relationship */
  readonly ad_daily_metrics: ReadonlyArray<AdDailyMetrics>;
  /** An aggregate relationship */
  readonly ad_daily_metrics_aggregate: AdDailyMetricsAggregate;
  /** fetch data from the table: "ad_daily_metrics" using primary key columns */
  readonly ad_daily_metrics_by_pk?: Maybe<AdDailyMetrics>;
  /** fetch data from the table: "ad_packages" */
  readonly ad_packages: ReadonlyArray<AdPackages>;
  /** fetch aggregated fields from the table: "ad_packages" */
  readonly ad_packages_aggregate: AdPackagesAggregate;
  /** fetch data from the table: "ad_packages" using primary key columns */
  readonly ad_packages_by_pk?: Maybe<AdPackages>;
  /** An array relationship */
  readonly ad_variants: ReadonlyArray<AdVariants>;
  /** An aggregate relationship */
  readonly ad_variants_aggregate: AdVariantsAggregate;
  /** fetch data from the table: "ad_variants" using primary key columns */
  readonly ad_variants_by_pk?: Maybe<AdVariants>;
  /** An array relationship */
  readonly addresses: ReadonlyArray<Addresses>;
  /** An aggregate relationship */
  readonly addresses_aggregate: AddressesAggregate;
  /** fetch data from the table: "addresses" using primary key columns */
  readonly addresses_by_pk?: Maybe<Addresses>;
  /** An array relationship */
  readonly ads: ReadonlyArray<Ads>;
  /** An aggregate relationship */
  readonly ads_aggregate: AdsAggregate;
  /** fetch data from the table: "ads" using primary key columns */
  readonly ads_by_pk?: Maybe<Ads>;
  /** fetch data from the table: "blacklisted_domains" */
  readonly blacklisted_domains: ReadonlyArray<BlacklistedDomains>;
  /** fetch aggregated fields from the table: "blacklisted_domains" */
  readonly blacklisted_domains_aggregate: BlacklistedDomainsAggregate;
  /** fetch data from the table: "blacklisted_domains" using primary key columns */
  readonly blacklisted_domains_by_pk?: Maybe<BlacklistedDomains>;
  /** An array relationship */
  readonly blacklisted_urls: ReadonlyArray<BlacklistedUrls>;
  /** An aggregate relationship */
  readonly blacklisted_urls_aggregate: BlacklistedUrlsAggregate;
  /** fetch data from the table: "blacklisted_urls" using primary key columns */
  readonly blacklisted_urls_by_pk?: Maybe<BlacklistedUrls>;
  /** fetch data from the table: "blocked_ips" */
  readonly blocked_ips: ReadonlyArray<BlockedIps>;
  /** fetch aggregated fields from the table: "blocked_ips" */
  readonly blocked_ips_aggregate: BlockedIpsAggregate;
  /** fetch data from the table: "blocked_ips" using primary key columns */
  readonly blocked_ips_by_pk?: Maybe<BlockedIps>;
  /** An array relationship */
  readonly bookmark_folders: ReadonlyArray<BookmarkFolders>;
  /** An aggregate relationship */
  readonly bookmark_folders_aggregate: BookmarkFoldersAggregate;
  /** fetch data from the table: "bookmark_folders" using primary key columns */
  readonly bookmark_folders_by_pk?: Maybe<BookmarkFolders>;
  /** An array relationship */
  readonly bookmarks: ReadonlyArray<Bookmarks>;
  /** An aggregate relationship */
  readonly bookmarks_aggregate: BookmarksAggregate;
  /** fetch data from the table: "bookmarks" using primary key columns */
  readonly bookmarks_by_pk?: Maybe<Bookmarks>;
  /** An array relationship */
  readonly business_domains: ReadonlyArray<BusinessDomains>;
  /** An aggregate relationship */
  readonly business_domains_aggregate: BusinessDomainsAggregate;
  /** fetch data from the table: "business_domains" using primary key columns */
  readonly business_domains_by_pk?: Maybe<BusinessDomains>;
  /** fetch data from the table: "categories" */
  readonly categories: ReadonlyArray<Categories>;
  /** fetch aggregated fields from the table: "categories" */
  readonly categories_aggregate: CategoriesAggregate;
  /** fetch data from the table: "categories" using primary key columns */
  readonly categories_by_pk?: Maybe<Categories>;
  /** An array relationship */
  readonly categorized_urls: ReadonlyArray<CategorizedUrls>;
  /** An aggregate relationship */
  readonly categorized_urls_aggregate: CategorizedUrlsAggregate;
  /** fetch data from the table: "categorized_urls" using primary key columns */
  readonly categorized_urls_by_pk?: Maybe<CategorizedUrls>;
  /** fetch data from the table: "circuit_breaker_states" */
  readonly circuit_breaker_states: ReadonlyArray<CircuitBreakerStates>;
  /** fetch aggregated fields from the table: "circuit_breaker_states" */
  readonly circuit_breaker_states_aggregate: CircuitBreakerStatesAggregate;
  /** fetch data from the table: "circuit_breaker_states" using primary key columns */
  readonly circuit_breaker_states_by_pk?: Maybe<CircuitBreakerStates>;
  /** An array relationship */
  readonly cities: ReadonlyArray<Cities>;
  /** An aggregate relationship */
  readonly cities_aggregate: CitiesAggregate;
  /** fetch data from the table: "cities" using primary key columns */
  readonly cities_by_pk?: Maybe<Cities>;
  /** An array relationship */
  readonly comments: ReadonlyArray<Comments>;
  /** An aggregate relationship */
  readonly comments_aggregate: CommentsAggregate;
  /** fetch data from the table: "comments" using primary key columns */
  readonly comments_by_pk?: Maybe<Comments>;
  /** An array relationship */
  readonly companies: ReadonlyArray<Companies>;
  /** An aggregate relationship */
  readonly companies_aggregate: CompaniesAggregate;
  /** fetch data from the table: "companies" using primary key columns */
  readonly companies_by_pk?: Maybe<Companies>;
  /** An array relationship */
  readonly company_contacts: ReadonlyArray<CompanyContacts>;
  /** An aggregate relationship */
  readonly company_contacts_aggregate: CompanyContactsAggregate;
  /** fetch data from the table: "company_contacts" using primary key columns */
  readonly company_contacts_by_pk?: Maybe<CompanyContacts>;
  /** An array relationship */
  readonly company_employees: ReadonlyArray<CompanyEmployees>;
  /** An aggregate relationship */
  readonly company_employees_aggregate: CompanyEmployeesAggregate;
  /** fetch data from the table: "company_employees" using primary key columns */
  readonly company_employees_by_pk?: Maybe<CompanyEmployees>;
  /** An array relationship */
  readonly company_extras: ReadonlyArray<CompanyExtras>;
  /** An aggregate relationship */
  readonly company_extras_aggregate: CompanyExtrasAggregate;
  /** fetch data from the table: "company_extras" using primary key columns */
  readonly company_extras_by_pk?: Maybe<CompanyExtras>;
  /** An array relationship */
  readonly company_metrics: ReadonlyArray<CompanyMetrics>;
  /** An aggregate relationship */
  readonly company_metrics_aggregate: CompanyMetricsAggregate;
  /** fetch data from the table: "company_metrics" using primary key columns */
  readonly company_metrics_by_pk?: Maybe<CompanyMetrics>;
  /** An array relationship */
  readonly contacts: ReadonlyArray<Contacts>;
  /** An aggregate relationship */
  readonly contacts_aggregate: ContactsAggregate;
  /** fetch data from the table: "contacts" using primary key columns */
  readonly contacts_by_pk?: Maybe<Contacts>;
  /** An array relationship */
  readonly content_categories: ReadonlyArray<ContentCategories>;
  /** An aggregate relationship */
  readonly content_categories_aggregate: ContentCategoriesAggregate;
  /** fetch data from the table: "content_categories" using primary key columns */
  readonly content_categories_by_pk?: Maybe<ContentCategories>;
  /** fetch data from the table: "content_scores" */
  readonly content_scores: ReadonlyArray<ContentScores>;
  /** fetch aggregated fields from the table: "content_scores" */
  readonly content_scores_aggregate: ContentScoresAggregate;
  /** An array relationship */
  readonly content_source_visits: ReadonlyArray<ContentSourceVisits>;
  /** An aggregate relationship */
  readonly content_source_visits_aggregate: ContentSourceVisitsAggregate;
  /** fetch data from the table: "content_source_visits" using primary key columns */
  readonly content_source_visits_by_pk?: Maybe<ContentSourceVisits>;
  /** An array relationship */
  readonly content_sources: ReadonlyArray<ContentSources>;
  /** An aggregate relationship */
  readonly content_sources_aggregate: ContentSourcesAggregate;
  /** fetch data from the table: "content_sources" using primary key columns */
  readonly content_sources_by_pk?: Maybe<ContentSources>;
  /** An array relationship */
  readonly content_statuses: ReadonlyArray<ContentStatuses>;
  /** An aggregate relationship */
  readonly content_statuses_aggregate: ContentStatusesAggregate;
  /** fetch data from the table: "content_statuses" using primary key columns */
  readonly content_statuses_by_pk?: Maybe<ContentStatuses>;
  /** An array relationship */
  readonly content_tags: ReadonlyArray<ContentTags>;
  /** An aggregate relationship */
  readonly content_tags_aggregate: ContentTagsAggregate;
  /** fetch data from the table: "content_tags" using primary key columns */
  readonly content_tags_by_pk?: Maybe<ContentTags>;
  /** fetch data from the table: "contents" */
  readonly contents: ReadonlyArray<Contents>;
  /** fetch aggregated fields from the table: "contents" */
  readonly contents_aggregate: ContentsAggregate;
  /** fetch data from the table: "contents" using primary key columns */
  readonly contents_by_pk?: Maybe<Contents>;
  /** fetch data from the table: "countries" */
  readonly countries: ReadonlyArray<Countries>;
  /** fetch aggregated fields from the table: "countries" */
  readonly countries_aggregate: CountriesAggregate;
  /** fetch data from the table: "countries" using primary key columns */
  readonly countries_by_pk?: Maybe<Countries>;
  /** An array relationship */
  readonly customer_payments: ReadonlyArray<CustomerPayments>;
  /** An aggregate relationship */
  readonly customer_payments_aggregate: CustomerPaymentsAggregate;
  /** fetch data from the table: "customer_payments" using primary key columns */
  readonly customer_payments_by_pk?: Maybe<CustomerPayments>;
  /** fetch data from the table: "customer_processed_webhooks" */
  readonly customer_processed_webhooks: ReadonlyArray<CustomerProcessedWebhooks>;
  /** fetch aggregated fields from the table: "customer_processed_webhooks" */
  readonly customer_processed_webhooks_aggregate: CustomerProcessedWebhooksAggregate;
  /** fetch data from the table: "customer_processed_webhooks" using primary key columns */
  readonly customer_processed_webhooks_by_pk?: Maybe<CustomerProcessedWebhooks>;
  /** An array relationship */
  readonly customer_refunds: ReadonlyArray<CustomerRefunds>;
  /** An aggregate relationship */
  readonly customer_refunds_aggregate: CustomerRefundsAggregate;
  /** fetch data from the table: "customer_refunds" using primary key columns */
  readonly customer_refunds_by_pk?: Maybe<CustomerRefunds>;
  /** fetch data from the table: "customer_subscription_plans" */
  readonly customer_subscription_plans: ReadonlyArray<CustomerSubscriptionPlans>;
  /** fetch aggregated fields from the table: "customer_subscription_plans" */
  readonly customer_subscription_plans_aggregate: CustomerSubscriptionPlansAggregate;
  /** fetch data from the table: "customer_subscription_plans" using primary key columns */
  readonly customer_subscription_plans_by_pk?: Maybe<CustomerSubscriptionPlans>;
  /** An array relationship */
  readonly customer_subscriptions: ReadonlyArray<CustomerSubscriptions>;
  /** An aggregate relationship */
  readonly customer_subscriptions_aggregate: CustomerSubscriptionsAggregate;
  /** fetch data from the table: "customer_subscriptions" using primary key columns */
  readonly customer_subscriptions_by_pk?: Maybe<CustomerSubscriptions>;
  /** fetch data from the table: "embedding_reviews" */
  readonly embedding_reviews: ReadonlyArray<EmbeddingReviews>;
  /** fetch aggregated fields from the table: "embedding_reviews" */
  readonly embedding_reviews_aggregate: EmbeddingReviewsAggregate;
  /** fetch data from the table: "embedding_reviews" using primary key columns */
  readonly embedding_reviews_by_pk?: Maybe<EmbeddingReviews>;
  /** fetch data from the table: "error_correlations" */
  readonly error_correlations: ReadonlyArray<ErrorCorrelations>;
  /** fetch aggregated fields from the table: "error_correlations" */
  readonly error_correlations_aggregate: ErrorCorrelationsAggregate;
  /** fetch data from the table: "error_frequency" */
  readonly error_frequency: ReadonlyArray<ErrorFrequency>;
  /** fetch aggregated fields from the table: "error_frequency" */
  readonly error_frequency_aggregate: ErrorFrequencyAggregate;
  /** fetch data from the table: "error_logs" */
  readonly error_logs: ReadonlyArray<ErrorLogs>;
  /** fetch aggregated fields from the table: "error_logs" */
  readonly error_logs_aggregate: ErrorLogsAggregate;
  /** fetch data from the table: "error_logs" using primary key columns */
  readonly error_logs_by_pk?: Maybe<ErrorLogs>;
  /** fetch data from the table: "error_metrics" */
  readonly error_metrics: ReadonlyArray<ErrorMetrics>;
  /** fetch aggregated fields from the table: "error_metrics" */
  readonly error_metrics_aggregate: ErrorMetricsAggregate;
  /** fetch data from the table: "error_patterns" */
  readonly error_patterns: ReadonlyArray<ErrorPatterns>;
  /** fetch aggregated fields from the table: "error_patterns" */
  readonly error_patterns_aggregate: ErrorPatternsAggregate;
  /** fetch data from the table: "error_stats" */
  readonly error_stats: ReadonlyArray<ErrorStats>;
  /** fetch aggregated fields from the table: "error_stats" */
  readonly error_stats_aggregate: ErrorStatsAggregate;
  /** fetch data from the table: "feature_requests" */
  readonly feature_requests: ReadonlyArray<FeatureRequests>;
  /** fetch aggregated fields from the table: "feature_requests" */
  readonly feature_requests_aggregate: FeatureRequestsAggregate;
  /** fetch data from the table: "feature_requests" using primary key columns */
  readonly feature_requests_by_pk?: Maybe<FeatureRequests>;
  /** An array relationship */
  readonly feature_votes: ReadonlyArray<FeatureVotes>;
  /** An aggregate relationship */
  readonly feature_votes_aggregate: FeatureVotesAggregate;
  /** fetch data from the table: "feature_votes" using primary key columns */
  readonly feature_votes_by_pk?: Maybe<FeatureVotes>;
  /** An array relationship */
  readonly feed_categories: ReadonlyArray<FeedCategories>;
  /** An aggregate relationship */
  readonly feed_categories_aggregate: FeedCategoriesAggregate;
  /** fetch data from the table: "feed_categories" using primary key columns */
  readonly feed_categories_by_pk?: Maybe<FeedCategories>;
  /** An array relationship */
  readonly feed_sources: ReadonlyArray<FeedSources>;
  /** An aggregate relationship */
  readonly feed_sources_aggregate: FeedSourcesAggregate;
  /** fetch data from the table: "feed_sources" using primary key columns */
  readonly feed_sources_by_pk?: Maybe<FeedSources>;
  /** An array relationship */
  readonly feedbacks: ReadonlyArray<Feedbacks>;
  /** An aggregate relationship */
  readonly feedbacks_aggregate: FeedbacksAggregate;
  /** fetch data from the table: "feedbacks" using primary key columns */
  readonly feedbacks_by_pk?: Maybe<Feedbacks>;
  /** An array relationship */
  readonly feeds: ReadonlyArray<Feeds>;
  /** An aggregate relationship */
  readonly feeds_aggregate: FeedsAggregate;
  /** fetch data from the table: "feeds" using primary key columns */
  readonly feeds_by_pk?: Maybe<Feeds>;
  /** An array relationship */
  readonly follows: ReadonlyArray<Follows>;
  /** An aggregate relationship */
  readonly follows_aggregate: FollowsAggregate;
  /** fetch data from the table: "follows" using primary key columns */
  readonly follows_by_pk?: Maybe<Follows>;
  /** fetch data from the table: "metric_definitions" */
  readonly metric_definitions: ReadonlyArray<MetricDefinitions>;
  /** fetch aggregated fields from the table: "metric_definitions" */
  readonly metric_definitions_aggregate: MetricDefinitionsAggregate;
  /** fetch data from the table: "metric_definitions" using primary key columns */
  readonly metric_definitions_by_pk?: Maybe<MetricDefinitions>;
  /** An array relationship */
  readonly news: ReadonlyArray<News>;
  /** An aggregate relationship */
  readonly news_aggregate: NewsAggregate;
  /** fetch data from the table: "news" using primary key columns */
  readonly news_by_pk?: Maybe<News>;
  /** fetch data from the table: "news_details" */
  readonly news_details: ReadonlyArray<NewsDetails>;
  /** fetch aggregated fields from the table: "news_details" */
  readonly news_details_aggregate: NewsDetailsAggregate;
  /** An array relationship */
  readonly news_summaries: ReadonlyArray<NewsSummaries>;
  /** An aggregate relationship */
  readonly news_summaries_aggregate: NewsSummariesAggregate;
  /** fetch data from the table: "news_summaries" using primary key columns */
  readonly news_summaries_by_pk?: Maybe<NewsSummaries>;
  /** An array relationship */
  readonly news_tags: ReadonlyArray<NewsTags>;
  /** An aggregate relationship */
  readonly news_tags_aggregate: NewsTagsAggregate;
  /** fetch data from the table: "news_tags" using primary key columns */
  readonly news_tags_by_pk?: Maybe<NewsTags>;
  /** fetch data from the table: "newsletters" */
  readonly newsletters: ReadonlyArray<Newsletters>;
  /** fetch aggregated fields from the table: "newsletters" */
  readonly newsletters_aggregate: NewslettersAggregate;
  /** fetch data from the table: "newsletters" using primary key columns */
  readonly newsletters_by_pk?: Maybe<Newsletters>;
  /** fetch data from the table: "payment_providers" */
  readonly payment_providers: ReadonlyArray<PaymentProviders>;
  /** fetch aggregated fields from the table: "payment_providers" */
  readonly payment_providers_aggregate: PaymentProvidersAggregate;
  /** fetch data from the table: "payment_providers" using primary key columns */
  readonly payment_providers_by_pk?: Maybe<PaymentProviders>;
  /** fetch data from the table: "plan_permissions" */
  readonly plan_permissions: ReadonlyArray<PlanPermissions>;
  /** fetch aggregated fields from the table: "plan_permissions" */
  readonly plan_permissions_aggregate: PlanPermissionsAggregate;
  /** fetch data from the table: "plan_permissions" using primary key columns */
  readonly plan_permissions_by_pk?: Maybe<PlanPermissions>;
  /** fetch data from the table: "recent_errors" */
  readonly recent_errors: ReadonlyArray<RecentErrors>;
  /** fetch aggregated fields from the table: "recent_errors" */
  readonly recent_errors_aggregate: RecentErrorsAggregate;
  /** fetch data from the table: "referral_stats" */
  readonly referral_stats: ReadonlyArray<ReferralStats>;
  /** fetch aggregated fields from the table: "referral_stats" */
  readonly referral_stats_aggregate: ReferralStatsAggregate;
  /** fetch data from the table: "referrals" */
  readonly referrals: ReadonlyArray<Referrals>;
  /** fetch aggregated fields from the table: "referrals" */
  readonly referrals_aggregate: ReferralsAggregate;
  /** fetch data from the table: "referrals" using primary key columns */
  readonly referrals_by_pk?: Maybe<Referrals>;
  /** fetch data from the table: "referrer_blocks" */
  readonly referrer_blocks: ReadonlyArray<ReferrerBlocks>;
  /** fetch aggregated fields from the table: "referrer_blocks" */
  readonly referrer_blocks_aggregate: ReferrerBlocksAggregate;
  /** fetch data from the table: "referrer_blocks" using primary key columns */
  readonly referrer_blocks_by_pk?: Maybe<ReferrerBlocks>;
  /** fetch data from the table: "referrer_risk_metrics" */
  readonly referrer_risk_metrics: ReadonlyArray<ReferrerRiskMetrics>;
  /** fetch aggregated fields from the table: "referrer_risk_metrics" */
  readonly referrer_risk_metrics_aggregate: ReferrerRiskMetricsAggregate;
  /** fetch data from the table: "research" */
  readonly research: ReadonlyArray<Research>;
  /** fetch aggregated fields from the table: "research" */
  readonly research_aggregate: ResearchAggregate;
  /** fetch data from the table: "research" using primary key columns */
  readonly research_by_pk?: Maybe<Research>;
  /** An array relationship */
  readonly research_embeddings: ReadonlyArray<ResearchEmbeddings>;
  /** An aggregate relationship */
  readonly research_embeddings_aggregate: ResearchEmbeddingsAggregate;
  /** fetch data from the table: "research_embeddings" using primary key columns */
  readonly research_embeddings_by_pk?: Maybe<ResearchEmbeddings>;
  /** An array relationship */
  readonly responses: ReadonlyArray<Responses>;
  /** An aggregate relationship */
  readonly responses_aggregate: ResponsesAggregate;
  /** fetch data from the table: "responses" using primary key columns */
  readonly responses_by_pk?: Maybe<Responses>;
  /** fetch data from the table: "role_hierarchy" */
  readonly role_hierarchy: ReadonlyArray<RoleHierarchy>;
  /** fetch aggregated fields from the table: "role_hierarchy" */
  readonly role_hierarchy_aggregate: RoleHierarchyAggregate;
  /** fetch data from the table: "role_hierarchy" using primary key columns */
  readonly role_hierarchy_by_pk?: Maybe<RoleHierarchy>;
  /** fetch data from the table: "role_permissions" */
  readonly role_permissions: ReadonlyArray<RolePermissions>;
  /** fetch aggregated fields from the table: "role_permissions" */
  readonly role_permissions_aggregate: RolePermissionsAggregate;
  /** fetch data from the table: "role_permissions" using primary key columns */
  readonly role_permissions_by_pk?: Maybe<RolePermissions>;
  /** fetch data from the table: "role_permissions_materialized" */
  readonly role_permissions_materialized: ReadonlyArray<RolePermissionsMaterialized>;
  /** fetch aggregated fields from the table: "role_permissions_materialized" */
  readonly role_permissions_materialized_aggregate: RolePermissionsMaterializedAggregate;
  /** fetch data from the table: "role_permissions_materialized" using primary key columns */
  readonly role_permissions_materialized_by_pk?: Maybe<RolePermissionsMaterialized>;
  /** fetch data from the table: "scoring_weights" */
  readonly scoring_weights: ReadonlyArray<ScoringWeights>;
  /** fetch aggregated fields from the table: "scoring_weights" */
  readonly scoring_weights_aggregate: ScoringWeightsAggregate;
  /** fetch data from the table: "scoring_weights" using primary key columns */
  readonly scoring_weights_by_pk?: Maybe<ScoringWeights>;
  /** fetch data from the table: "searches" */
  readonly searches: ReadonlyArray<Searches>;
  /** fetch aggregated fields from the table: "searches" */
  readonly searches_aggregate: SearchesAggregate;
  /** fetch data from the table: "searches" using primary key columns */
  readonly searches_by_pk?: Maybe<Searches>;
  /** fetch data from the table: "security_metrics" */
  readonly security_metrics: ReadonlyArray<SecurityMetrics>;
  /** fetch aggregated fields from the table: "security_metrics" */
  readonly security_metrics_aggregate: SecurityMetricsAggregate;
  /** fetch data from the table: "slow_query_patterns" */
  readonly slow_query_patterns: ReadonlyArray<SlowQueryPatterns>;
  /** fetch aggregated fields from the table: "slow_query_patterns" */
  readonly slow_query_patterns_aggregate: SlowQueryPatternsAggregate;
  /** fetch data from the table: "social_media" */
  readonly social_media: ReadonlyArray<SocialMedia>;
  /** fetch aggregated fields from the table: "social_media" */
  readonly social_media_aggregate: SocialMediaAggregate;
  /** fetch data from the table: "social_media" using primary key columns */
  readonly social_media_by_pk?: Maybe<SocialMedia>;
  /** An array relationship */
  readonly spider_metrics: ReadonlyArray<SpiderMetrics>;
  /** An aggregate relationship */
  readonly spider_metrics_aggregate: SpiderMetricsAggregate;
  /** fetch data from the table: "spider_metrics" using primary key columns */
  readonly spider_metrics_by_pk?: Maybe<SpiderMetrics>;
  /** fetch data from the table: "strapi_migrations" */
  readonly strapi_migrations: ReadonlyArray<StrapiMigrations>;
  /** fetch aggregated fields from the table: "strapi_migrations" */
  readonly strapi_migrations_aggregate: StrapiMigrationsAggregate;
  /** fetch data from the table: "strapi_migrations" using primary key columns */
  readonly strapi_migrations_by_pk?: Maybe<StrapiMigrations>;
  /** fetch data from the table: "strapi_migrations_internal" */
  readonly strapi_migrations_internal: ReadonlyArray<StrapiMigrationsInternal>;
  /** fetch aggregated fields from the table: "strapi_migrations_internal" */
  readonly strapi_migrations_internal_aggregate: StrapiMigrationsInternalAggregate;
  /** fetch data from the table: "strapi_migrations_internal" using primary key columns */
  readonly strapi_migrations_internal_by_pk?: Maybe<StrapiMigrationsInternal>;
  /** fetch data from the table: "table_maintenance_log" */
  readonly table_maintenance_log: ReadonlyArray<TableMaintenanceLog>;
  /** fetch aggregated fields from the table: "table_maintenance_log" */
  readonly table_maintenance_log_aggregate: TableMaintenanceLogAggregate;
  /** fetch data from the table: "table_maintenance_log" using primary key columns */
  readonly table_maintenance_log_by_pk?: Maybe<TableMaintenanceLog>;
  /** fetch data from the table: "table_query_performance" */
  readonly table_query_performance: ReadonlyArray<TableQueryPerformance>;
  /** fetch aggregated fields from the table: "table_query_performance" */
  readonly table_query_performance_aggregate: TableQueryPerformanceAggregate;
  /** fetch data from the table: "table_sequence_usage" */
  readonly table_sequence_usage: ReadonlyArray<TableSequenceUsage>;
  /** fetch aggregated fields from the table: "table_sequence_usage" */
  readonly table_sequence_usage_aggregate: TableSequenceUsageAggregate;
  /** fetch data from the table: "table_statistics" */
  readonly table_statistics: ReadonlyArray<TableStatistics>;
  /** fetch aggregated fields from the table: "table_statistics" */
  readonly table_statistics_aggregate: TableStatisticsAggregate;
  /** fetch data from the table: "table_statistics" using primary key columns */
  readonly table_statistics_by_pk?: Maybe<TableStatistics>;
  /** fetch data from the table: "tags" */
  readonly tags: ReadonlyArray<Tags>;
  /** fetch aggregated fields from the table: "tags" */
  readonly tags_aggregate: TagsAggregate;
  /** fetch data from the table: "tags" using primary key columns */
  readonly tags_by_pk?: Maybe<Tags>;
  /** fetch data from the table: "user_metrics" */
  readonly user_metrics: ReadonlyArray<UserMetrics>;
  /** fetch aggregated fields from the table: "user_metrics" */
  readonly user_metrics_aggregate: UserMetricsAggregate;
  /** fetch data from the table: "user_metrics" using primary key columns */
  readonly user_metrics_by_pk?: Maybe<UserMetrics>;
  /** fetch data from the table: "user_profiles" */
  readonly user_profiles: ReadonlyArray<UserProfiles>;
  /** fetch aggregated fields from the table: "user_profiles" */
  readonly user_profiles_aggregate: UserProfilesAggregate;
  /** fetch data from the table: "user_profiles" using primary key columns */
  readonly user_profiles_by_pk?: Maybe<UserProfiles>;
  /** fetch data from the table: "votes" */
  readonly votes: ReadonlyArray<Votes>;
  /** fetch aggregated fields from the table: "votes" */
  readonly votes_aggregate: VotesAggregate;
  /** fetch data from the table: "votes" using primary key columns */
  readonly votes_by_pk?: Maybe<Votes>;
  /** fetch data from the table: "workflows" */
  readonly workflows: ReadonlyArray<Workflows>;
  /** fetch aggregated fields from the table: "workflows" */
  readonly workflows_aggregate: WorkflowsAggregate;
  /** fetch data from the table: "workflows" using primary key columns */
  readonly workflows_by_pk?: Maybe<Workflows>;
}

export type QueryRootAdDailyMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdDailyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdDailyMetricsOrderBy>>;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
};

export type QueryRootAdDailyMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdDailyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdDailyMetricsOrderBy>>;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
};

export type QueryRootAdDailyMetricsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootAdPackagesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdPackagesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdPackagesOrderBy>>;
  where?: InputMaybe<AdPackagesBoolExp>;
};

export type QueryRootAdPackagesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdPackagesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdPackagesOrderBy>>;
  where?: InputMaybe<AdPackagesBoolExp>;
};

export type QueryRootAdPackagesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootAdVariantsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdVariantsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdVariantsOrderBy>>;
  where?: InputMaybe<AdVariantsBoolExp>;
};

export type QueryRootAdVariantsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdVariantsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdVariantsOrderBy>>;
  where?: InputMaybe<AdVariantsBoolExp>;
};

export type QueryRootAdVariantsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootAddressesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

export type QueryRootAddressesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

export type QueryRootAddressesByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootAdsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdsOrderBy>>;
  where?: InputMaybe<AdsBoolExp>;
};

export type QueryRootAdsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdsOrderBy>>;
  where?: InputMaybe<AdsBoolExp>;
};

export type QueryRootAdsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootBlacklistedDomainsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BlacklistedDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BlacklistedDomainsOrderBy>>;
  where?: InputMaybe<BlacklistedDomainsBoolExp>;
};

export type QueryRootBlacklistedDomainsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BlacklistedDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BlacklistedDomainsOrderBy>>;
  where?: InputMaybe<BlacklistedDomainsBoolExp>;
};

export type QueryRootBlacklistedDomainsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootBlacklistedUrlsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BlacklistedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BlacklistedUrlsOrderBy>>;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
};

export type QueryRootBlacklistedUrlsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BlacklistedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BlacklistedUrlsOrderBy>>;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
};

export type QueryRootBlacklistedUrlsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootBlockedIpsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BlockedIpsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BlockedIpsOrderBy>>;
  where?: InputMaybe<BlockedIpsBoolExp>;
};

export type QueryRootBlockedIpsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BlockedIpsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BlockedIpsOrderBy>>;
  where?: InputMaybe<BlockedIpsBoolExp>;
};

export type QueryRootBlockedIpsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootBookmarkFoldersArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BookmarkFoldersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BookmarkFoldersOrderBy>>;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
};

export type QueryRootBookmarkFoldersAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BookmarkFoldersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BookmarkFoldersOrderBy>>;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
};

export type QueryRootBookmarkFoldersByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootBookmarksArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BookmarksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BookmarksOrderBy>>;
  where?: InputMaybe<BookmarksBoolExp>;
};

export type QueryRootBookmarksAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BookmarksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BookmarksOrderBy>>;
  where?: InputMaybe<BookmarksBoolExp>;
};

export type QueryRootBookmarksByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootBusinessDomainsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BusinessDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BusinessDomainsOrderBy>>;
  where?: InputMaybe<BusinessDomainsBoolExp>;
};

export type QueryRootBusinessDomainsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BusinessDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BusinessDomainsOrderBy>>;
  where?: InputMaybe<BusinessDomainsBoolExp>;
};

export type QueryRootBusinessDomainsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootCategoriesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CategoriesOrderBy>>;
  where?: InputMaybe<CategoriesBoolExp>;
};

export type QueryRootCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CategoriesOrderBy>>;
  where?: InputMaybe<CategoriesBoolExp>;
};

export type QueryRootCategoriesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootCategorizedUrlsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CategorizedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CategorizedUrlsOrderBy>>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
};

export type QueryRootCategorizedUrlsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CategorizedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CategorizedUrlsOrderBy>>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
};

export type QueryRootCategorizedUrlsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootCircuitBreakerStatesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CircuitBreakerStatesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CircuitBreakerStatesOrderBy>>;
  where?: InputMaybe<CircuitBreakerStatesBoolExp>;
};

export type QueryRootCircuitBreakerStatesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CircuitBreakerStatesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CircuitBreakerStatesOrderBy>>;
  where?: InputMaybe<CircuitBreakerStatesBoolExp>;
};

export type QueryRootCircuitBreakerStatesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootCitiesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CitiesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CitiesOrderBy>>;
  where?: InputMaybe<CitiesBoolExp>;
};

export type QueryRootCitiesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CitiesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CitiesOrderBy>>;
  where?: InputMaybe<CitiesBoolExp>;
};

export type QueryRootCitiesByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCommentsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CommentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CommentsOrderBy>>;
  where?: InputMaybe<CommentsBoolExp>;
};

export type QueryRootCommentsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CommentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CommentsOrderBy>>;
  where?: InputMaybe<CommentsBoolExp>;
};

export type QueryRootCommentsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootCompaniesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompaniesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompaniesOrderBy>>;
  where?: InputMaybe<CompaniesBoolExp>;
};

export type QueryRootCompaniesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompaniesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompaniesOrderBy>>;
  where?: InputMaybe<CompaniesBoolExp>;
};

export type QueryRootCompaniesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootCompanyContactsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyContactsOrderBy>>;
  where?: InputMaybe<CompanyContactsBoolExp>;
};

export type QueryRootCompanyContactsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyContactsOrderBy>>;
  where?: InputMaybe<CompanyContactsBoolExp>;
};

export type QueryRootCompanyContactsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCompanyEmployeesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyEmployeesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyEmployeesOrderBy>>;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
};

export type QueryRootCompanyEmployeesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyEmployeesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyEmployeesOrderBy>>;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
};

export type QueryRootCompanyEmployeesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootCompanyExtrasArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyExtrasSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyExtrasOrderBy>>;
  where?: InputMaybe<CompanyExtrasBoolExp>;
};

export type QueryRootCompanyExtrasAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyExtrasSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyExtrasOrderBy>>;
  where?: InputMaybe<CompanyExtrasBoolExp>;
};

export type QueryRootCompanyExtrasByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCompanyMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyMetricsOrderBy>>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
};

export type QueryRootCompanyMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyMetricsOrderBy>>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
};

export type QueryRootCompanyMetricsByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootContactsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContactsOrderBy>>;
  where?: InputMaybe<ContactsBoolExp>;
};

export type QueryRootContactsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContactsOrderBy>>;
  where?: InputMaybe<ContactsBoolExp>;
};

export type QueryRootContactsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootContentCategoriesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentCategoriesOrderBy>>;
  where?: InputMaybe<ContentCategoriesBoolExp>;
};

export type QueryRootContentCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentCategoriesOrderBy>>;
  where?: InputMaybe<ContentCategoriesBoolExp>;
};

export type QueryRootContentCategoriesByPkArgs = {
  category_id: Scalars["bigint"]["input"];
  content_id: Scalars["uuid"]["input"];
};

export type QueryRootContentScoresArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentScoresSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentScoresOrderBy>>;
  where?: InputMaybe<ContentScoresBoolExp>;
};

export type QueryRootContentScoresAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentScoresSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentScoresOrderBy>>;
  where?: InputMaybe<ContentScoresBoolExp>;
};

export type QueryRootContentSourceVisitsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

export type QueryRootContentSourceVisitsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

export type QueryRootContentSourceVisitsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootContentSourcesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentSourcesOrderBy>>;
  where?: InputMaybe<ContentSourcesBoolExp>;
};

export type QueryRootContentSourcesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentSourcesOrderBy>>;
  where?: InputMaybe<ContentSourcesBoolExp>;
};

export type QueryRootContentSourcesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootContentStatusesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentStatusesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentStatusesOrderBy>>;
  where?: InputMaybe<ContentStatusesBoolExp>;
};

export type QueryRootContentStatusesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentStatusesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentStatusesOrderBy>>;
  where?: InputMaybe<ContentStatusesBoolExp>;
};

export type QueryRootContentStatusesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootContentTagsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentTagsOrderBy>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

export type QueryRootContentTagsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentTagsOrderBy>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

export type QueryRootContentTagsByPkArgs = {
  content_id: Scalars["uuid"]["input"];
  tag_id: Scalars["Int"]["input"];
};

export type QueryRootContentsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentsOrderBy>>;
  where?: InputMaybe<ContentsBoolExp>;
};

export type QueryRootContentsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentsOrderBy>>;
  where?: InputMaybe<ContentsBoolExp>;
};

export type QueryRootContentsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootCountriesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CountriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CountriesOrderBy>>;
  where?: InputMaybe<CountriesBoolExp>;
};

export type QueryRootCountriesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CountriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CountriesOrderBy>>;
  where?: InputMaybe<CountriesBoolExp>;
};

export type QueryRootCountriesByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCustomerPaymentsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

export type QueryRootCustomerPaymentsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

export type QueryRootCustomerPaymentsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCustomerProcessedWebhooksArgs = {
  distinct_on?: InputMaybe<
    ReadonlyArray<CustomerProcessedWebhooksSelectColumn>
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerProcessedWebhooksOrderBy>>;
  where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
};

export type QueryRootCustomerProcessedWebhooksAggregateArgs = {
  distinct_on?: InputMaybe<
    ReadonlyArray<CustomerProcessedWebhooksSelectColumn>
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerProcessedWebhooksOrderBy>>;
  where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
};

export type QueryRootCustomerProcessedWebhooksByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCustomerRefundsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerRefundsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerRefundsOrderBy>>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
};

export type QueryRootCustomerRefundsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerRefundsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerRefundsOrderBy>>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
};

export type QueryRootCustomerRefundsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCustomerSubscriptionPlansArgs = {
  distinct_on?: InputMaybe<
    ReadonlyArray<CustomerSubscriptionPlansSelectColumn>
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerSubscriptionPlansOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
};

export type QueryRootCustomerSubscriptionPlansAggregateArgs = {
  distinct_on?: InputMaybe<
    ReadonlyArray<CustomerSubscriptionPlansSelectColumn>
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerSubscriptionPlansOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
};

export type QueryRootCustomerSubscriptionPlansByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootCustomerSubscriptionsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

export type QueryRootCustomerSubscriptionsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

export type QueryRootCustomerSubscriptionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootEmbeddingReviewsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<EmbeddingReviewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<EmbeddingReviewsOrderBy>>;
  where?: InputMaybe<EmbeddingReviewsBoolExp>;
};

export type QueryRootEmbeddingReviewsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<EmbeddingReviewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<EmbeddingReviewsOrderBy>>;
  where?: InputMaybe<EmbeddingReviewsBoolExp>;
};

export type QueryRootEmbeddingReviewsByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootErrorCorrelationsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorCorrelationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorCorrelationsOrderBy>>;
  where?: InputMaybe<ErrorCorrelationsBoolExp>;
};

export type QueryRootErrorCorrelationsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorCorrelationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorCorrelationsOrderBy>>;
  where?: InputMaybe<ErrorCorrelationsBoolExp>;
};

export type QueryRootErrorFrequencyArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorFrequencySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorFrequencyOrderBy>>;
  where?: InputMaybe<ErrorFrequencyBoolExp>;
};

export type QueryRootErrorFrequencyAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorFrequencySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorFrequencyOrderBy>>;
  where?: InputMaybe<ErrorFrequencyBoolExp>;
};

export type QueryRootErrorLogsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorLogsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorLogsOrderBy>>;
  where?: InputMaybe<ErrorLogsBoolExp>;
};

export type QueryRootErrorLogsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorLogsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorLogsOrderBy>>;
  where?: InputMaybe<ErrorLogsBoolExp>;
};

export type QueryRootErrorLogsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootErrorMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorMetricsOrderBy>>;
  where?: InputMaybe<ErrorMetricsBoolExp>;
};

export type QueryRootErrorMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorMetricsOrderBy>>;
  where?: InputMaybe<ErrorMetricsBoolExp>;
};

export type QueryRootErrorPatternsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorPatternsOrderBy>>;
  where?: InputMaybe<ErrorPatternsBoolExp>;
};

export type QueryRootErrorPatternsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorPatternsOrderBy>>;
  where?: InputMaybe<ErrorPatternsBoolExp>;
};

export type QueryRootErrorStatsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorStatsOrderBy>>;
  where?: InputMaybe<ErrorStatsBoolExp>;
};

export type QueryRootErrorStatsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorStatsOrderBy>>;
  where?: InputMaybe<ErrorStatsBoolExp>;
};

export type QueryRootFeatureRequestsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeatureRequestsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeatureRequestsOrderBy>>;
  where?: InputMaybe<FeatureRequestsBoolExp>;
};

export type QueryRootFeatureRequestsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeatureRequestsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeatureRequestsOrderBy>>;
  where?: InputMaybe<FeatureRequestsBoolExp>;
};

export type QueryRootFeatureRequestsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootFeatureVotesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeatureVotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeatureVotesOrderBy>>;
  where?: InputMaybe<FeatureVotesBoolExp>;
};

export type QueryRootFeatureVotesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeatureVotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeatureVotesOrderBy>>;
  where?: InputMaybe<FeatureVotesBoolExp>;
};

export type QueryRootFeatureVotesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootFeedCategoriesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedCategoriesOrderBy>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

export type QueryRootFeedCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedCategoriesOrderBy>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

export type QueryRootFeedCategoriesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootFeedSourcesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

export type QueryRootFeedSourcesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

export type QueryRootFeedSourcesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootFeedbacksArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedbacksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedbacksOrderBy>>;
  where?: InputMaybe<FeedbacksBoolExp>;
};

export type QueryRootFeedbacksAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedbacksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedbacksOrderBy>>;
  where?: InputMaybe<FeedbacksBoolExp>;
};

export type QueryRootFeedbacksByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootFeedsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedsOrderBy>>;
  where?: InputMaybe<FeedsBoolExp>;
};

export type QueryRootFeedsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedsOrderBy>>;
  where?: InputMaybe<FeedsBoolExp>;
};

export type QueryRootFeedsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootFollowsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FollowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FollowsOrderBy>>;
  where?: InputMaybe<FollowsBoolExp>;
};

export type QueryRootFollowsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FollowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FollowsOrderBy>>;
  where?: InputMaybe<FollowsBoolExp>;
};

export type QueryRootFollowsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootMetricDefinitionsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<MetricDefinitionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<MetricDefinitionsOrderBy>>;
  where?: InputMaybe<MetricDefinitionsBoolExp>;
};

export type QueryRootMetricDefinitionsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<MetricDefinitionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<MetricDefinitionsOrderBy>>;
  where?: InputMaybe<MetricDefinitionsBoolExp>;
};

export type QueryRootMetricDefinitionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootNewsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsOrderBy>>;
  where?: InputMaybe<NewsBoolExp>;
};

export type QueryRootNewsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsOrderBy>>;
  where?: InputMaybe<NewsBoolExp>;
};

export type QueryRootNewsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootNewsDetailsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsDetailsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsDetailsOrderBy>>;
  where?: InputMaybe<NewsDetailsBoolExp>;
};

export type QueryRootNewsDetailsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsDetailsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsDetailsOrderBy>>;
  where?: InputMaybe<NewsDetailsBoolExp>;
};

export type QueryRootNewsSummariesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsSummariesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsSummariesOrderBy>>;
  where?: InputMaybe<NewsSummariesBoolExp>;
};

export type QueryRootNewsSummariesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsSummariesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsSummariesOrderBy>>;
  where?: InputMaybe<NewsSummariesBoolExp>;
};

export type QueryRootNewsSummariesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootNewsTagsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsTagsOrderBy>>;
  where?: InputMaybe<NewsTagsBoolExp>;
};

export type QueryRootNewsTagsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsTagsOrderBy>>;
  where?: InputMaybe<NewsTagsBoolExp>;
};

export type QueryRootNewsTagsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootNewslettersArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewslettersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewslettersOrderBy>>;
  where?: InputMaybe<NewslettersBoolExp>;
};

export type QueryRootNewslettersAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewslettersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewslettersOrderBy>>;
  where?: InputMaybe<NewslettersBoolExp>;
};

export type QueryRootNewslettersByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootPaymentProvidersArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<PaymentProvidersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<PaymentProvidersOrderBy>>;
  where?: InputMaybe<PaymentProvidersBoolExp>;
};

export type QueryRootPaymentProvidersAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<PaymentProvidersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<PaymentProvidersOrderBy>>;
  where?: InputMaybe<PaymentProvidersBoolExp>;
};

export type QueryRootPaymentProvidersByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootPlanPermissionsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<PlanPermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<PlanPermissionsOrderBy>>;
  where?: InputMaybe<PlanPermissionsBoolExp>;
};

export type QueryRootPlanPermissionsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<PlanPermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<PlanPermissionsOrderBy>>;
  where?: InputMaybe<PlanPermissionsBoolExp>;
};

export type QueryRootPlanPermissionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootRecentErrorsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<RecentErrorsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<RecentErrorsOrderBy>>;
  where?: InputMaybe<RecentErrorsBoolExp>;
};

export type QueryRootRecentErrorsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<RecentErrorsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<RecentErrorsOrderBy>>;
  where?: InputMaybe<RecentErrorsBoolExp>;
};

export type QueryRootReferralStatsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferralStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferralStatsOrderBy>>;
  where?: InputMaybe<ReferralStatsBoolExp>;
};

export type QueryRootReferralStatsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferralStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferralStatsOrderBy>>;
  where?: InputMaybe<ReferralStatsBoolExp>;
};

export type QueryRootReferralsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferralsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferralsOrderBy>>;
  where?: InputMaybe<ReferralsBoolExp>;
};

export type QueryRootReferralsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferralsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferralsOrderBy>>;
  where?: InputMaybe<ReferralsBoolExp>;
};

export type QueryRootReferralsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootReferrerBlocksArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferrerBlocksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferrerBlocksOrderBy>>;
  where?: InputMaybe<ReferrerBlocksBoolExp>;
};

export type QueryRootReferrerBlocksAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferrerBlocksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferrerBlocksOrderBy>>;
  where?: InputMaybe<ReferrerBlocksBoolExp>;
};

export type QueryRootReferrerBlocksByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootReferrerRiskMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferrerRiskMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferrerRiskMetricsOrderBy>>;
  where?: InputMaybe<ReferrerRiskMetricsBoolExp>;
};

export type QueryRootReferrerRiskMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferrerRiskMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferrerRiskMetricsOrderBy>>;
  where?: InputMaybe<ReferrerRiskMetricsBoolExp>;
};

export type QueryRootResearchArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResearchSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResearchOrderBy>>;
  where?: InputMaybe<ResearchBoolExp>;
};

export type QueryRootResearchAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResearchSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResearchOrderBy>>;
  where?: InputMaybe<ResearchBoolExp>;
};

export type QueryRootResearchByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootResearchEmbeddingsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResearchEmbeddingsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResearchEmbeddingsOrderBy>>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

export type QueryRootResearchEmbeddingsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResearchEmbeddingsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResearchEmbeddingsOrderBy>>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

export type QueryRootResearchEmbeddingsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootResponsesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResponsesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResponsesOrderBy>>;
  where?: InputMaybe<ResponsesBoolExp>;
};

export type QueryRootResponsesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResponsesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResponsesOrderBy>>;
  where?: InputMaybe<ResponsesBoolExp>;
};

export type QueryRootResponsesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootRoleHierarchyArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<RoleHierarchySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<RoleHierarchyOrderBy>>;
  where?: InputMaybe<RoleHierarchyBoolExp>;
};

export type QueryRootRoleHierarchyAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<RoleHierarchySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<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<ReadonlyArray<RolePermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<RolePermissionsOrderBy>>;
  where?: InputMaybe<RolePermissionsBoolExp>;
};

export type QueryRootRolePermissionsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<RolePermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<RolePermissionsOrderBy>>;
  where?: InputMaybe<RolePermissionsBoolExp>;
};

export type QueryRootRolePermissionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootRolePermissionsMaterializedArgs = {
  distinct_on?: InputMaybe<
    ReadonlyArray<RolePermissionsMaterializedSelectColumn>
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<RolePermissionsMaterializedOrderBy>>;
  where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
};

export type QueryRootRolePermissionsMaterializedAggregateArgs = {
  distinct_on?: InputMaybe<
    ReadonlyArray<RolePermissionsMaterializedSelectColumn>
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<RolePermissionsMaterializedOrderBy>>;
  where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
};

export type QueryRootRolePermissionsMaterializedByPkArgs = {
  role: Scalars["app_role_enum"]["input"];
};

export type QueryRootScoringWeightsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ScoringWeightsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ScoringWeightsOrderBy>>;
  where?: InputMaybe<ScoringWeightsBoolExp>;
};

export type QueryRootScoringWeightsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ScoringWeightsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ScoringWeightsOrderBy>>;
  where?: InputMaybe<ScoringWeightsBoolExp>;
};

export type QueryRootScoringWeightsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootSearchesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SearchesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SearchesOrderBy>>;
  where?: InputMaybe<SearchesBoolExp>;
};

export type QueryRootSearchesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SearchesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SearchesOrderBy>>;
  where?: InputMaybe<SearchesBoolExp>;
};

export type QueryRootSearchesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootSecurityMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SecurityMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SecurityMetricsOrderBy>>;
  where?: InputMaybe<SecurityMetricsBoolExp>;
};

export type QueryRootSecurityMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SecurityMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SecurityMetricsOrderBy>>;
  where?: InputMaybe<SecurityMetricsBoolExp>;
};

export type QueryRootSlowQueryPatternsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SlowQueryPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SlowQueryPatternsOrderBy>>;
  where?: InputMaybe<SlowQueryPatternsBoolExp>;
};

export type QueryRootSlowQueryPatternsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SlowQueryPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SlowQueryPatternsOrderBy>>;
  where?: InputMaybe<SlowQueryPatternsBoolExp>;
};

export type QueryRootSocialMediaArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SocialMediaSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SocialMediaOrderBy>>;
  where?: InputMaybe<SocialMediaBoolExp>;
};

export type QueryRootSocialMediaAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SocialMediaSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SocialMediaOrderBy>>;
  where?: InputMaybe<SocialMediaBoolExp>;
};

export type QueryRootSocialMediaByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootSpiderMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SpiderMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SpiderMetricsOrderBy>>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
};

export type QueryRootSpiderMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SpiderMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SpiderMetricsOrderBy>>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
};

export type QueryRootSpiderMetricsByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type QueryRootStrapiMigrationsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<StrapiMigrationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<StrapiMigrationsOrderBy>>;
  where?: InputMaybe<StrapiMigrationsBoolExp>;
};

export type QueryRootStrapiMigrationsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<StrapiMigrationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<StrapiMigrationsOrderBy>>;
  where?: InputMaybe<StrapiMigrationsBoolExp>;
};

export type QueryRootStrapiMigrationsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootStrapiMigrationsInternalArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<StrapiMigrationsInternalSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<StrapiMigrationsInternalOrderBy>>;
  where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
};

export type QueryRootStrapiMigrationsInternalAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<StrapiMigrationsInternalSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<StrapiMigrationsInternalOrderBy>>;
  where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
};

export type QueryRootStrapiMigrationsInternalByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootTableMaintenanceLogArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableMaintenanceLogSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TableMaintenanceLogOrderBy>>;
  where?: InputMaybe<TableMaintenanceLogBoolExp>;
};

export type QueryRootTableMaintenanceLogAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableMaintenanceLogSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TableMaintenanceLogOrderBy>>;
  where?: InputMaybe<TableMaintenanceLogBoolExp>;
};

export type QueryRootTableMaintenanceLogByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootTableQueryPerformanceArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableQueryPerformanceSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TableQueryPerformanceOrderBy>>;
  where?: InputMaybe<TableQueryPerformanceBoolExp>;
};

export type QueryRootTableQueryPerformanceAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableQueryPerformanceSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TableQueryPerformanceOrderBy>>;
  where?: InputMaybe<TableQueryPerformanceBoolExp>;
};

export type QueryRootTableSequenceUsageArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableSequenceUsageSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TableSequenceUsageOrderBy>>;
  where?: InputMaybe<TableSequenceUsageBoolExp>;
};

export type QueryRootTableSequenceUsageAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableSequenceUsageSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TableSequenceUsageOrderBy>>;
  where?: InputMaybe<TableSequenceUsageBoolExp>;
};

export type QueryRootTableStatisticsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableStatisticsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TableStatisticsOrderBy>>;
  where?: InputMaybe<TableStatisticsBoolExp>;
};

export type QueryRootTableStatisticsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableStatisticsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TableStatisticsOrderBy>>;
  where?: InputMaybe<TableStatisticsBoolExp>;
};

export type QueryRootTableStatisticsByPkArgs = {
  capture_time: Scalars["timestamptz"]["input"];
  table_name: Scalars["String"]["input"];
};

export type QueryRootTagsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TagsOrderBy>>;
  where?: InputMaybe<TagsBoolExp>;
};

export type QueryRootTagsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TagsOrderBy>>;
  where?: InputMaybe<TagsBoolExp>;
};

export type QueryRootTagsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type QueryRootUserMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<UserMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<UserMetricsOrderBy>>;
  where?: InputMaybe<UserMetricsBoolExp>;
};

export type QueryRootUserMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<UserMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<UserMetricsOrderBy>>;
  where?: InputMaybe<UserMetricsBoolExp>;
};

export type QueryRootUserMetricsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootUserProfilesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<UserProfilesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<UserProfilesOrderBy>>;
  where?: InputMaybe<UserProfilesBoolExp>;
};

export type QueryRootUserProfilesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<UserProfilesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<UserProfilesOrderBy>>;
  where?: InputMaybe<UserProfilesBoolExp>;
};

export type QueryRootUserProfilesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootVotesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<VotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<VotesOrderBy>>;
  where?: InputMaybe<VotesBoolExp>;
};

export type QueryRootVotesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<VotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<VotesOrderBy>>;
  where?: InputMaybe<VotesBoolExp>;
};

export type QueryRootVotesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type QueryRootWorkflowsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<WorkflowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<WorkflowsOrderBy>>;
  where?: InputMaybe<WorkflowsBoolExp>;
};

export type QueryRootWorkflowsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<WorkflowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<WorkflowsOrderBy>>;
  where?: InputMaybe<WorkflowsBoolExp>;
};

export type QueryRootWorkflowsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

/** columns and relationships of "recent_errors" */
export interface RecentErrors {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly error_type?: Maybe<Scalars["error_type"]["output"]>;
  readonly message?: Maybe<Scalars["String"]["output"]>;
  readonly metadata?: Maybe<Scalars["jsonb"]["output"]>;
  readonly service_name?: Maybe<Scalars["String"]["output"]>;
  readonly 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 interface RecentErrorsAggregate {
  readonly aggregate?: Maybe<RecentErrorsAggregateFields>;
  readonly nodes: ReadonlyArray<RecentErrors>;
}

/** aggregate fields of "recent_errors" */
export interface RecentErrorsAggregateFields {
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<RecentErrorsMaxFields>;
  readonly min?: Maybe<RecentErrorsMinFields>;
}

/** aggregate fields of "recent_errors" */
export type RecentErrorsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<RecentErrorsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

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

/** Boolean expression to filter rows from the table "recent_errors". All fields are combined with a logical 'AND'. */
export interface RecentErrorsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<RecentErrorsBoolExp>>;
  readonly _not?: InputMaybe<RecentErrorsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<RecentErrorsBoolExp>>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly error_type?: InputMaybe<ErrorTypeComparisonExp>;
  readonly message?: InputMaybe<StringComparisonExp>;
  readonly metadata?: InputMaybe<JsonbComparisonExp>;
  readonly service_name?: InputMaybe<StringComparisonExp>;
  readonly severity?: InputMaybe<ErrorSeverityComparisonExp>;
}

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface RecentErrorsDeleteAtPathInput {
  readonly metadata?: InputMaybe<ReadonlyArray<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 interface RecentErrorsDeleteElemInput {
  readonly metadata?: InputMaybe<Scalars["Int"]["input"]>;
}

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

/** input type for inserting data into table "recent_errors" */
export interface RecentErrorsInsertInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  readonly message?: InputMaybe<Scalars["String"]["input"]>;
  readonly metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly service_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly severity?: InputMaybe<Scalars["error_severity"]["input"]>;
}

/** aggregate max on columns */
export interface RecentErrorsMaxFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly error_type?: Maybe<Scalars["error_type"]["output"]>;
  readonly message?: Maybe<Scalars["String"]["output"]>;
  readonly service_name?: Maybe<Scalars["String"]["output"]>;
  readonly severity?: Maybe<Scalars["error_severity"]["output"]>;
}

/** aggregate min on columns */
export interface RecentErrorsMinFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly error_type?: Maybe<Scalars["error_type"]["output"]>;
  readonly message?: Maybe<Scalars["String"]["output"]>;
  readonly service_name?: Maybe<Scalars["String"]["output"]>;
  readonly severity?: Maybe<Scalars["error_severity"]["output"]>;
}

/** response of any mutation on the table "recent_errors" */
export interface RecentErrorsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<RecentErrors>;
}

/** Ordering options when selecting data from "recent_errors". */
export interface RecentErrorsOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly error_type?: InputMaybe<OrderBy>;
  readonly message?: InputMaybe<OrderBy>;
  readonly metadata?: InputMaybe<OrderBy>;
  readonly service_name?: InputMaybe<OrderBy>;
  readonly severity?: InputMaybe<OrderBy>;
}

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

/** select columns of table "recent_errors" */
export type RecentErrorsSelectColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "error_type"
  /** column name */
  | "message"
  /** column name */
  | "metadata"
  /** column name */
  | "service_name"
  /** column name */
  | "severity";

/** input type for updating data in table "recent_errors" */
export interface RecentErrorsSetInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  readonly message?: InputMaybe<Scalars["String"]["input"]>;
  readonly metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly service_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly severity?: InputMaybe<Scalars["error_severity"]["input"]>;
}

/** Streaming cursor of the table "recent_errors" */
export interface RecentErrorsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: RecentErrorsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface RecentErrorsStreamCursorValueInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly error_type?: InputMaybe<Scalars["error_type"]["input"]>;
  readonly message?: InputMaybe<Scalars["String"]["input"]>;
  readonly metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly service_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly severity?: InputMaybe<Scalars["error_severity"]["input"]>;
}

export interface RecentErrorsUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<RecentErrorsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<RecentErrorsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<RecentErrorsDeleteKeyInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<RecentErrorsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<RecentErrorsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: RecentErrorsBoolExp;
}

/** columns and relationships of "referral_stats" */
export interface ReferralStats {
  readonly active_days?: Maybe<Scalars["bigint"]["output"]>;
  readonly avg_conversion_time_hours?: Maybe<Scalars["numeric"]["output"]>;
  readonly conversion_rate?: Maybe<Scalars["numeric"]["output"]>;
  readonly conversions?: Maybe<Scalars["bigint"]["output"]>;
  readonly referrer_code?: Maybe<Scalars["String"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  readonly total_value?: Maybe<Scalars["numeric"]["output"]>;
  readonly unique_visitors?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregated selection of "referral_stats" */
export interface ReferralStatsAggregate {
  readonly aggregate?: Maybe<ReferralStatsAggregateFields>;
  readonly nodes: ReadonlyArray<ReferralStats>;
}

/** aggregate fields of "referral_stats" */
export interface ReferralStatsAggregateFields {
  readonly avg?: Maybe<ReferralStatsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ReferralStatsMaxFields>;
  readonly min?: Maybe<ReferralStatsMinFields>;
  readonly stddev?: Maybe<ReferralStatsStddevFields>;
  readonly stddev_pop?: Maybe<ReferralStatsStddevPopFields>;
  readonly stddev_samp?: Maybe<ReferralStatsStddevSampFields>;
  readonly sum?: Maybe<ReferralStatsSumFields>;
  readonly var_pop?: Maybe<ReferralStatsVarPopFields>;
  readonly var_samp?: Maybe<ReferralStatsVarSampFields>;
  readonly variance?: Maybe<ReferralStatsVarianceFields>;
}

/** aggregate fields of "referral_stats" */
export type ReferralStatsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ReferralStatsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface ReferralStatsAvgFields {
  readonly active_days?: Maybe<Scalars["Float"]["output"]>;
  readonly avg_conversion_time_hours?: Maybe<Scalars["Float"]["output"]>;
  readonly conversion_rate?: Maybe<Scalars["Float"]["output"]>;
  readonly conversions?: Maybe<Scalars["Float"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["Float"]["output"]>;
  readonly total_value?: Maybe<Scalars["Float"]["output"]>;
  readonly 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 interface ReferralStatsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ReferralStatsBoolExp>>;
  readonly _not?: InputMaybe<ReferralStatsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ReferralStatsBoolExp>>;
  readonly active_days?: InputMaybe<BigintComparisonExp>;
  readonly avg_conversion_time_hours?: InputMaybe<NumericComparisonExp>;
  readonly conversion_rate?: InputMaybe<NumericComparisonExp>;
  readonly conversions?: InputMaybe<BigintComparisonExp>;
  readonly referrer_code?: InputMaybe<StringComparisonExp>;
  readonly total_referrals?: InputMaybe<BigintComparisonExp>;
  readonly total_value?: InputMaybe<NumericComparisonExp>;
  readonly unique_visitors?: InputMaybe<BigintComparisonExp>;
}

/** aggregate max on columns */
export interface ReferralStatsMaxFields {
  readonly active_days?: Maybe<Scalars["bigint"]["output"]>;
  readonly avg_conversion_time_hours?: Maybe<Scalars["numeric"]["output"]>;
  readonly conversion_rate?: Maybe<Scalars["numeric"]["output"]>;
  readonly conversions?: Maybe<Scalars["bigint"]["output"]>;
  readonly referrer_code?: Maybe<Scalars["String"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  readonly total_value?: Maybe<Scalars["numeric"]["output"]>;
  readonly unique_visitors?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate min on columns */
export interface ReferralStatsMinFields {
  readonly active_days?: Maybe<Scalars["bigint"]["output"]>;
  readonly avg_conversion_time_hours?: Maybe<Scalars["numeric"]["output"]>;
  readonly conversion_rate?: Maybe<Scalars["numeric"]["output"]>;
  readonly conversions?: Maybe<Scalars["bigint"]["output"]>;
  readonly referrer_code?: Maybe<Scalars["String"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  readonly total_value?: Maybe<Scalars["numeric"]["output"]>;
  readonly unique_visitors?: Maybe<Scalars["bigint"]["output"]>;
}

/** Ordering options when selecting data from "referral_stats". */
export interface ReferralStatsOrderBy {
  readonly active_days?: InputMaybe<OrderBy>;
  readonly avg_conversion_time_hours?: InputMaybe<OrderBy>;
  readonly conversion_rate?: InputMaybe<OrderBy>;
  readonly conversions?: InputMaybe<OrderBy>;
  readonly referrer_code?: InputMaybe<OrderBy>;
  readonly total_referrals?: InputMaybe<OrderBy>;
  readonly total_value?: InputMaybe<OrderBy>;
  readonly unique_visitors?: InputMaybe<OrderBy>;
}

/** select columns of table "referral_stats" */
export type ReferralStatsSelectColumn =
  /** column name */
  | "active_days"
  /** column name */
  | "avg_conversion_time_hours"
  /** column name */
  | "conversion_rate"
  /** column name */
  | "conversions"
  /** column name */
  | "referrer_code"
  /** column name */
  | "total_referrals"
  /** column name */
  | "total_value"
  /** column name */
  | "unique_visitors";

/** aggregate stddev on columns */
export interface ReferralStatsStddevFields {
  readonly active_days?: Maybe<Scalars["Float"]["output"]>;
  readonly avg_conversion_time_hours?: Maybe<Scalars["Float"]["output"]>;
  readonly conversion_rate?: Maybe<Scalars["Float"]["output"]>;
  readonly conversions?: Maybe<Scalars["Float"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["Float"]["output"]>;
  readonly total_value?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_visitors?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface ReferralStatsStddevPopFields {
  readonly active_days?: Maybe<Scalars["Float"]["output"]>;
  readonly avg_conversion_time_hours?: Maybe<Scalars["Float"]["output"]>;
  readonly conversion_rate?: Maybe<Scalars["Float"]["output"]>;
  readonly conversions?: Maybe<Scalars["Float"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["Float"]["output"]>;
  readonly total_value?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_visitors?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface ReferralStatsStddevSampFields {
  readonly active_days?: Maybe<Scalars["Float"]["output"]>;
  readonly avg_conversion_time_hours?: Maybe<Scalars["Float"]["output"]>;
  readonly conversion_rate?: Maybe<Scalars["Float"]["output"]>;
  readonly conversions?: Maybe<Scalars["Float"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["Float"]["output"]>;
  readonly total_value?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_visitors?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "referral_stats" */
export interface ReferralStatsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ReferralStatsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ReferralStatsStreamCursorValueInput {
  readonly active_days?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly avg_conversion_time_hours?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly conversion_rate?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly conversions?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  readonly total_referrals?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly total_value?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly unique_visitors?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** aggregate sum on columns */
export interface ReferralStatsSumFields {
  readonly active_days?: Maybe<Scalars["bigint"]["output"]>;
  readonly avg_conversion_time_hours?: Maybe<Scalars["numeric"]["output"]>;
  readonly conversion_rate?: Maybe<Scalars["numeric"]["output"]>;
  readonly conversions?: Maybe<Scalars["bigint"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  readonly total_value?: Maybe<Scalars["numeric"]["output"]>;
  readonly unique_visitors?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate var_pop on columns */
export interface ReferralStatsVarPopFields {
  readonly active_days?: Maybe<Scalars["Float"]["output"]>;
  readonly avg_conversion_time_hours?: Maybe<Scalars["Float"]["output"]>;
  readonly conversion_rate?: Maybe<Scalars["Float"]["output"]>;
  readonly conversions?: Maybe<Scalars["Float"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["Float"]["output"]>;
  readonly total_value?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_visitors?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface ReferralStatsVarSampFields {
  readonly active_days?: Maybe<Scalars["Float"]["output"]>;
  readonly avg_conversion_time_hours?: Maybe<Scalars["Float"]["output"]>;
  readonly conversion_rate?: Maybe<Scalars["Float"]["output"]>;
  readonly conversions?: Maybe<Scalars["Float"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["Float"]["output"]>;
  readonly total_value?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_visitors?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface ReferralStatsVarianceFields {
  readonly active_days?: Maybe<Scalars["Float"]["output"]>;
  readonly avg_conversion_time_hours?: Maybe<Scalars["Float"]["output"]>;
  readonly conversion_rate?: Maybe<Scalars["Float"]["output"]>;
  readonly conversions?: Maybe<Scalars["Float"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["Float"]["output"]>;
  readonly total_value?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_visitors?: Maybe<Scalars["Float"]["output"]>;
}

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

/** columns and relationships of "referrals" */
export interface Referrals {
  readonly browser?: Maybe<Scalars["String"]["output"]>;
  readonly client_fingerprint?: Maybe<Scalars["String"]["output"]>;
  readonly conversion_value?: Maybe<Scalars["numeric"]["output"]>;
  readonly converted_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly country_code?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly device_type?: Maybe<Scalars["String"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  readonly ip_address?: Maybe<Scalars["inet"]["output"]>;
  readonly is_suspicious?: Maybe<Scalars["Boolean"]["output"]>;
  readonly landing_page?: Maybe<Scalars["String"]["output"]>;
  readonly last_failed_attempt?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly referral_status?: Maybe<Scalars["referral_status"]["output"]>;
  readonly referrer_code: Scalars["String"]["output"];
  readonly region?: Maybe<Scalars["String"]["output"]>;
  readonly security_flags?: Maybe<Scalars["jsonb"]["output"]>;
  readonly user_agent?: Maybe<Scalars["String"]["output"]>;
  readonly utm_campaign?: Maybe<Scalars["String"]["output"]>;
  readonly utm_medium?: Maybe<Scalars["String"]["output"]>;
  readonly utm_source?: Maybe<Scalars["String"]["output"]>;
  readonly validation_attempts?: Maybe<Scalars["Int"]["output"]>;
  readonly visitor_id: Scalars["uuid"]["output"];
}

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

/** aggregated selection of "referrals" */
export interface ReferralsAggregate {
  readonly aggregate?: Maybe<ReferralsAggregateFields>;
  readonly nodes: ReadonlyArray<Referrals>;
}

/** aggregate fields of "referrals" */
export interface ReferralsAggregateFields {
  readonly avg?: Maybe<ReferralsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ReferralsMaxFields>;
  readonly min?: Maybe<ReferralsMinFields>;
  readonly stddev?: Maybe<ReferralsStddevFields>;
  readonly stddev_pop?: Maybe<ReferralsStddevPopFields>;
  readonly stddev_samp?: Maybe<ReferralsStddevSampFields>;
  readonly sum?: Maybe<ReferralsSumFields>;
  readonly var_pop?: Maybe<ReferralsVarPopFields>;
  readonly var_samp?: Maybe<ReferralsVarSampFields>;
  readonly variance?: Maybe<ReferralsVarianceFields>;
}

/** aggregate fields of "referrals" */
export type ReferralsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ReferralsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export interface ReferralsAppendInput {
  readonly security_flags?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** aggregate avg on columns */
export interface ReferralsAvgFields {
  readonly conversion_value?: Maybe<Scalars["Float"]["output"]>;
  readonly validation_attempts?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "referrals". All fields are combined with a logical 'AND'. */
export interface ReferralsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ReferralsBoolExp>>;
  readonly _not?: InputMaybe<ReferralsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ReferralsBoolExp>>;
  readonly browser?: InputMaybe<StringComparisonExp>;
  readonly client_fingerprint?: InputMaybe<StringComparisonExp>;
  readonly conversion_value?: InputMaybe<NumericComparisonExp>;
  readonly converted_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly country_code?: InputMaybe<StringComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly device_type?: InputMaybe<StringComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly ip_address?: InputMaybe<InetComparisonExp>;
  readonly is_suspicious?: InputMaybe<BooleanComparisonExp>;
  readonly landing_page?: InputMaybe<StringComparisonExp>;
  readonly last_failed_attempt?: InputMaybe<TimestamptzComparisonExp>;
  readonly referral_status?: InputMaybe<ReferralStatusComparisonExp>;
  readonly referrer_code?: InputMaybe<StringComparisonExp>;
  readonly region?: InputMaybe<StringComparisonExp>;
  readonly security_flags?: InputMaybe<JsonbComparisonExp>;
  readonly user_agent?: InputMaybe<StringComparisonExp>;
  readonly utm_campaign?: InputMaybe<StringComparisonExp>;
  readonly utm_medium?: InputMaybe<StringComparisonExp>;
  readonly utm_source?: InputMaybe<StringComparisonExp>;
  readonly validation_attempts?: InputMaybe<IntComparisonExp>;
  readonly visitor_id?: InputMaybe<UuidComparisonExp>;
}

/** unique or primary key constraints on table "referrals" */
export type ReferralsConstraint =
  /** unique or primary key constraint on columns "id" */
  "referrals_pkey";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface ReferralsDeleteAtPathInput {
  readonly security_flags?: InputMaybe<
    ReadonlyArray<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 interface ReferralsDeleteElemInput {
  readonly security_flags?: InputMaybe<Scalars["Int"]["input"]>;
}

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

/** input type for incrementing numeric columns in table "referrals" */
export interface ReferralsIncInput {
  readonly conversion_value?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly validation_attempts?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "referrals" */
export interface ReferralsInsertInput {
  readonly browser?: InputMaybe<Scalars["String"]["input"]>;
  readonly client_fingerprint?: InputMaybe<Scalars["String"]["input"]>;
  readonly conversion_value?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly converted_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly country_code?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly device_type?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly ip_address?: InputMaybe<Scalars["inet"]["input"]>;
  readonly is_suspicious?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly landing_page?: InputMaybe<Scalars["String"]["input"]>;
  readonly last_failed_attempt?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly referral_status?: InputMaybe<Scalars["referral_status"]["input"]>;
  readonly referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  readonly region?: InputMaybe<Scalars["String"]["input"]>;
  readonly security_flags?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly user_agent?: InputMaybe<Scalars["String"]["input"]>;
  readonly utm_campaign?: InputMaybe<Scalars["String"]["input"]>;
  readonly utm_medium?: InputMaybe<Scalars["String"]["input"]>;
  readonly utm_source?: InputMaybe<Scalars["String"]["input"]>;
  readonly validation_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  readonly visitor_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** aggregate max on columns */
export interface ReferralsMaxFields {
  readonly browser?: Maybe<Scalars["String"]["output"]>;
  readonly client_fingerprint?: Maybe<Scalars["String"]["output"]>;
  readonly conversion_value?: Maybe<Scalars["numeric"]["output"]>;
  readonly converted_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly country_code?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly device_type?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly landing_page?: Maybe<Scalars["String"]["output"]>;
  readonly last_failed_attempt?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly referral_status?: Maybe<Scalars["referral_status"]["output"]>;
  readonly referrer_code?: Maybe<Scalars["String"]["output"]>;
  readonly region?: Maybe<Scalars["String"]["output"]>;
  readonly user_agent?: Maybe<Scalars["String"]["output"]>;
  readonly utm_campaign?: Maybe<Scalars["String"]["output"]>;
  readonly utm_medium?: Maybe<Scalars["String"]["output"]>;
  readonly utm_source?: Maybe<Scalars["String"]["output"]>;
  readonly validation_attempts?: Maybe<Scalars["Int"]["output"]>;
  readonly visitor_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** aggregate min on columns */
export interface ReferralsMinFields {
  readonly browser?: Maybe<Scalars["String"]["output"]>;
  readonly client_fingerprint?: Maybe<Scalars["String"]["output"]>;
  readonly conversion_value?: Maybe<Scalars["numeric"]["output"]>;
  readonly converted_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly country_code?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly device_type?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly landing_page?: Maybe<Scalars["String"]["output"]>;
  readonly last_failed_attempt?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly referral_status?: Maybe<Scalars["referral_status"]["output"]>;
  readonly referrer_code?: Maybe<Scalars["String"]["output"]>;
  readonly region?: Maybe<Scalars["String"]["output"]>;
  readonly user_agent?: Maybe<Scalars["String"]["output"]>;
  readonly utm_campaign?: Maybe<Scalars["String"]["output"]>;
  readonly utm_medium?: Maybe<Scalars["String"]["output"]>;
  readonly utm_source?: Maybe<Scalars["String"]["output"]>;
  readonly validation_attempts?: Maybe<Scalars["Int"]["output"]>;
  readonly visitor_id?: Maybe<Scalars["uuid"]["output"]>;
}

/** response of any mutation on the table "referrals" */
export interface ReferralsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Referrals>;
}

/** on_conflict condition type for table "referrals" */
export interface ReferralsOnConflict {
  readonly constraint: ReferralsConstraint;
  readonly update_columns: ReadonlyArray<ReferralsUpdateColumn>;
  readonly where?: InputMaybe<ReferralsBoolExp>;
}

/** Ordering options when selecting data from "referrals". */
export interface ReferralsOrderBy {
  readonly browser?: InputMaybe<OrderBy>;
  readonly client_fingerprint?: InputMaybe<OrderBy>;
  readonly conversion_value?: InputMaybe<OrderBy>;
  readonly converted_at?: InputMaybe<OrderBy>;
  readonly country_code?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly device_type?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly ip_address?: InputMaybe<OrderBy>;
  readonly is_suspicious?: InputMaybe<OrderBy>;
  readonly landing_page?: InputMaybe<OrderBy>;
  readonly last_failed_attempt?: InputMaybe<OrderBy>;
  readonly referral_status?: InputMaybe<OrderBy>;
  readonly referrer_code?: InputMaybe<OrderBy>;
  readonly region?: InputMaybe<OrderBy>;
  readonly security_flags?: InputMaybe<OrderBy>;
  readonly user_agent?: InputMaybe<OrderBy>;
  readonly utm_campaign?: InputMaybe<OrderBy>;
  readonly utm_medium?: InputMaybe<OrderBy>;
  readonly utm_source?: InputMaybe<OrderBy>;
  readonly validation_attempts?: InputMaybe<OrderBy>;
  readonly visitor_id?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: referrals */
export interface ReferralsPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** prepend existing jsonb value of filtered columns with new jsonb value */
export interface ReferralsPrependInput {
  readonly security_flags?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** select columns of table "referrals" */
export type ReferralsSelectColumn =
  /** column name */
  | "browser"
  /** column name */
  | "client_fingerprint"
  /** column name */
  | "conversion_value"
  /** column name */
  | "converted_at"
  /** column name */
  | "country_code"
  /** column name */
  | "created_at"
  /** column name */
  | "device_type"
  /** column name */
  | "id"
  /** column name */
  | "ip_address"
  /** column name */
  | "is_suspicious"
  /** column name */
  | "landing_page"
  /** column name */
  | "last_failed_attempt"
  /** column name */
  | "referral_status"
  /** column name */
  | "referrer_code"
  /** column name */
  | "region"
  /** column name */
  | "security_flags"
  /** column name */
  | "user_agent"
  /** column name */
  | "utm_campaign"
  /** column name */
  | "utm_medium"
  /** column name */
  | "utm_source"
  /** column name */
  | "validation_attempts"
  /** column name */
  | "visitor_id";

/** input type for updating data in table "referrals" */
export interface ReferralsSetInput {
  readonly browser?: InputMaybe<Scalars["String"]["input"]>;
  readonly client_fingerprint?: InputMaybe<Scalars["String"]["input"]>;
  readonly conversion_value?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly converted_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly country_code?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly device_type?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly ip_address?: InputMaybe<Scalars["inet"]["input"]>;
  readonly is_suspicious?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly landing_page?: InputMaybe<Scalars["String"]["input"]>;
  readonly last_failed_attempt?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly referral_status?: InputMaybe<Scalars["referral_status"]["input"]>;
  readonly referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  readonly region?: InputMaybe<Scalars["String"]["input"]>;
  readonly security_flags?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly user_agent?: InputMaybe<Scalars["String"]["input"]>;
  readonly utm_campaign?: InputMaybe<Scalars["String"]["input"]>;
  readonly utm_medium?: InputMaybe<Scalars["String"]["input"]>;
  readonly utm_source?: InputMaybe<Scalars["String"]["input"]>;
  readonly validation_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  readonly visitor_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** aggregate stddev on columns */
export interface ReferralsStddevFields {
  readonly conversion_value?: Maybe<Scalars["Float"]["output"]>;
  readonly validation_attempts?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface ReferralsStddevPopFields {
  readonly conversion_value?: Maybe<Scalars["Float"]["output"]>;
  readonly validation_attempts?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface ReferralsStddevSampFields {
  readonly conversion_value?: Maybe<Scalars["Float"]["output"]>;
  readonly validation_attempts?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "referrals" */
export interface ReferralsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ReferralsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ReferralsStreamCursorValueInput {
  readonly browser?: InputMaybe<Scalars["String"]["input"]>;
  readonly client_fingerprint?: InputMaybe<Scalars["String"]["input"]>;
  readonly conversion_value?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly converted_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly country_code?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly device_type?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly ip_address?: InputMaybe<Scalars["inet"]["input"]>;
  readonly is_suspicious?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly landing_page?: InputMaybe<Scalars["String"]["input"]>;
  readonly last_failed_attempt?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly referral_status?: InputMaybe<Scalars["referral_status"]["input"]>;
  readonly referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  readonly region?: InputMaybe<Scalars["String"]["input"]>;
  readonly security_flags?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly user_agent?: InputMaybe<Scalars["String"]["input"]>;
  readonly utm_campaign?: InputMaybe<Scalars["String"]["input"]>;
  readonly utm_medium?: InputMaybe<Scalars["String"]["input"]>;
  readonly utm_source?: InputMaybe<Scalars["String"]["input"]>;
  readonly validation_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  readonly visitor_id?: InputMaybe<Scalars["uuid"]["input"]>;
}

/** aggregate sum on columns */
export interface ReferralsSumFields {
  readonly conversion_value?: Maybe<Scalars["numeric"]["output"]>;
  readonly validation_attempts?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "referrals" */
export type ReferralsUpdateColumn =
  /** column name */
  | "browser"
  /** column name */
  | "client_fingerprint"
  /** column name */
  | "conversion_value"
  /** column name */
  | "converted_at"
  /** column name */
  | "country_code"
  /** column name */
  | "created_at"
  /** column name */
  | "device_type"
  /** column name */
  | "id"
  /** column name */
  | "ip_address"
  /** column name */
  | "is_suspicious"
  /** column name */
  | "landing_page"
  /** column name */
  | "last_failed_attempt"
  /** column name */
  | "referral_status"
  /** column name */
  | "referrer_code"
  /** column name */
  | "region"
  /** column name */
  | "security_flags"
  /** column name */
  | "user_agent"
  /** column name */
  | "utm_campaign"
  /** column name */
  | "utm_medium"
  /** column name */
  | "utm_source"
  /** column name */
  | "validation_attempts"
  /** column name */
  | "visitor_id";

export interface ReferralsUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<ReferralsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<ReferralsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<ReferralsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<ReferralsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<ReferralsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<ReferralsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: ReferralsBoolExp;
}

/** aggregate var_pop on columns */
export interface ReferralsVarPopFields {
  readonly conversion_value?: Maybe<Scalars["Float"]["output"]>;
  readonly validation_attempts?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface ReferralsVarSampFields {
  readonly conversion_value?: Maybe<Scalars["Float"]["output"]>;
  readonly validation_attempts?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface ReferralsVarianceFields {
  readonly conversion_value?: Maybe<Scalars["Float"]["output"]>;
  readonly validation_attempts?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "referrer_blocks" */
export interface ReferrerBlocks {
  readonly blocked_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly blocked_by: Scalars["String"]["output"];
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  readonly is_permanent?: Maybe<Scalars["Boolean"]["output"]>;
  readonly reason?: Maybe<Scalars["String"]["output"]>;
  readonly referrer_code: Scalars["String"]["output"];
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** aggregated selection of "referrer_blocks" */
export interface ReferrerBlocksAggregate {
  readonly aggregate?: Maybe<ReferrerBlocksAggregateFields>;
  readonly nodes: ReadonlyArray<ReferrerBlocks>;
}

/** aggregate fields of "referrer_blocks" */
export interface ReferrerBlocksAggregateFields {
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ReferrerBlocksMaxFields>;
  readonly min?: Maybe<ReferrerBlocksMinFields>;
}

/** aggregate fields of "referrer_blocks" */
export type ReferrerBlocksAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<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 interface ReferrerBlocksBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ReferrerBlocksBoolExp>>;
  readonly _not?: InputMaybe<ReferrerBlocksBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ReferrerBlocksBoolExp>>;
  readonly blocked_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly blocked_by?: InputMaybe<StringComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly is_permanent?: InputMaybe<BooleanComparisonExp>;
  readonly reason?: InputMaybe<StringComparisonExp>;
  readonly referrer_code?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
}

/** unique or primary key constraints on table "referrer_blocks" */
export type ReferrerBlocksConstraint =
  /** unique or primary key constraint on columns "referrer_code" */
  | "idx_referrer_blocks_code"
  /** unique or primary key constraint on columns "id" */
  | "referrer_blocks_pkey";

/** input type for inserting data into table "referrer_blocks" */
export interface ReferrerBlocksInsertInput {
  readonly blocked_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly blocked_by?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly is_permanent?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly reason?: InputMaybe<Scalars["String"]["input"]>;
  readonly referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate max on columns */
export interface ReferrerBlocksMaxFields {
  readonly blocked_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly blocked_by?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly reason?: Maybe<Scalars["String"]["output"]>;
  readonly referrer_code?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** aggregate min on columns */
export interface ReferrerBlocksMinFields {
  readonly blocked_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly blocked_by?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly reason?: Maybe<Scalars["String"]["output"]>;
  readonly referrer_code?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** response of any mutation on the table "referrer_blocks" */
export interface ReferrerBlocksMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<ReferrerBlocks>;
}

/** on_conflict condition type for table "referrer_blocks" */
export interface ReferrerBlocksOnConflict {
  readonly constraint: ReferrerBlocksConstraint;
  readonly update_columns: ReadonlyArray<ReferrerBlocksUpdateColumn>;
  readonly where?: InputMaybe<ReferrerBlocksBoolExp>;
}

/** Ordering options when selecting data from "referrer_blocks". */
export interface ReferrerBlocksOrderBy {
  readonly blocked_at?: InputMaybe<OrderBy>;
  readonly blocked_by?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly is_permanent?: InputMaybe<OrderBy>;
  readonly reason?: InputMaybe<OrderBy>;
  readonly referrer_code?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: referrer_blocks */
export interface ReferrerBlocksPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** select columns of table "referrer_blocks" */
export type ReferrerBlocksSelectColumn =
  /** column name */
  | "blocked_at"
  /** column name */
  | "blocked_by"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "is_permanent"
  /** column name */
  | "reason"
  /** column name */
  | "referrer_code"
  /** column name */
  | "updated_at";

/** input type for updating data in table "referrer_blocks" */
export interface ReferrerBlocksSetInput {
  readonly blocked_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly blocked_by?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly is_permanent?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly reason?: InputMaybe<Scalars["String"]["input"]>;
  readonly referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** Streaming cursor of the table "referrer_blocks" */
export interface ReferrerBlocksStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ReferrerBlocksStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ReferrerBlocksStreamCursorValueInput {
  readonly blocked_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly blocked_by?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly is_permanent?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly reason?: InputMaybe<Scalars["String"]["input"]>;
  readonly referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** update columns of table "referrer_blocks" */
export type ReferrerBlocksUpdateColumn =
  /** column name */
  | "blocked_at"
  /** column name */
  | "blocked_by"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "is_permanent"
  /** column name */
  | "reason"
  /** column name */
  | "referrer_code"
  /** column name */
  | "updated_at";

export interface ReferrerBlocksUpdates {
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<ReferrerBlocksSetInput>;
  /** filter the rows which have to be updated */
  readonly where: ReferrerBlocksBoolExp;
}

/** columns and relationships of "referrer_risk_metrics" */
export interface ReferrerRiskMetrics {
  readonly active_days?: Maybe<Scalars["bigint"]["output"]>;
  readonly high_attempt_instances?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_validation_attempts?: Maybe<Scalars["Int"]["output"]>;
  readonly referrer_code?: Maybe<Scalars["String"]["output"]>;
  readonly suspicious_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly suspicious_percentage?: Maybe<Scalars["numeric"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregated selection of "referrer_risk_metrics" */
export interface ReferrerRiskMetricsAggregate {
  readonly aggregate?: Maybe<ReferrerRiskMetricsAggregateFields>;
  readonly nodes: ReadonlyArray<ReferrerRiskMetrics>;
}

/** aggregate fields of "referrer_risk_metrics" */
export interface ReferrerRiskMetricsAggregateFields {
  readonly avg?: Maybe<ReferrerRiskMetricsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ReferrerRiskMetricsMaxFields>;
  readonly min?: Maybe<ReferrerRiskMetricsMinFields>;
  readonly stddev?: Maybe<ReferrerRiskMetricsStddevFields>;
  readonly stddev_pop?: Maybe<ReferrerRiskMetricsStddevPopFields>;
  readonly stddev_samp?: Maybe<ReferrerRiskMetricsStddevSampFields>;
  readonly sum?: Maybe<ReferrerRiskMetricsSumFields>;
  readonly var_pop?: Maybe<ReferrerRiskMetricsVarPopFields>;
  readonly var_samp?: Maybe<ReferrerRiskMetricsVarSampFields>;
  readonly variance?: Maybe<ReferrerRiskMetricsVarianceFields>;
}

/** aggregate fields of "referrer_risk_metrics" */
export type ReferrerRiskMetricsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ReferrerRiskMetricsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface ReferrerRiskMetricsAvgFields {
  readonly active_days?: Maybe<Scalars["Float"]["output"]>;
  readonly high_attempt_instances?: Maybe<Scalars["Float"]["output"]>;
  readonly max_validation_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_count?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_percentage?: Maybe<Scalars["Float"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["Float"]["output"]>;
  readonly 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 interface ReferrerRiskMetricsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ReferrerRiskMetricsBoolExp>>;
  readonly _not?: InputMaybe<ReferrerRiskMetricsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ReferrerRiskMetricsBoolExp>>;
  readonly active_days?: InputMaybe<BigintComparisonExp>;
  readonly high_attempt_instances?: InputMaybe<BigintComparisonExp>;
  readonly max_validation_attempts?: InputMaybe<IntComparisonExp>;
  readonly referrer_code?: InputMaybe<StringComparisonExp>;
  readonly suspicious_count?: InputMaybe<BigintComparisonExp>;
  readonly suspicious_percentage?: InputMaybe<NumericComparisonExp>;
  readonly total_referrals?: InputMaybe<BigintComparisonExp>;
  readonly unique_ips?: InputMaybe<BigintComparisonExp>;
}

/** aggregate max on columns */
export interface ReferrerRiskMetricsMaxFields {
  readonly active_days?: Maybe<Scalars["bigint"]["output"]>;
  readonly high_attempt_instances?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_validation_attempts?: Maybe<Scalars["Int"]["output"]>;
  readonly referrer_code?: Maybe<Scalars["String"]["output"]>;
  readonly suspicious_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly suspicious_percentage?: Maybe<Scalars["numeric"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate min on columns */
export interface ReferrerRiskMetricsMinFields {
  readonly active_days?: Maybe<Scalars["bigint"]["output"]>;
  readonly high_attempt_instances?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_validation_attempts?: Maybe<Scalars["Int"]["output"]>;
  readonly referrer_code?: Maybe<Scalars["String"]["output"]>;
  readonly suspicious_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly suspicious_percentage?: Maybe<Scalars["numeric"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["bigint"]["output"]>;
}

/** Ordering options when selecting data from "referrer_risk_metrics". */
export interface ReferrerRiskMetricsOrderBy {
  readonly active_days?: InputMaybe<OrderBy>;
  readonly high_attempt_instances?: InputMaybe<OrderBy>;
  readonly max_validation_attempts?: InputMaybe<OrderBy>;
  readonly referrer_code?: InputMaybe<OrderBy>;
  readonly suspicious_count?: InputMaybe<OrderBy>;
  readonly suspicious_percentage?: InputMaybe<OrderBy>;
  readonly total_referrals?: InputMaybe<OrderBy>;
  readonly unique_ips?: InputMaybe<OrderBy>;
}

/** select columns of table "referrer_risk_metrics" */
export type ReferrerRiskMetricsSelectColumn =
  /** column name */
  | "active_days"
  /** column name */
  | "high_attempt_instances"
  /** column name */
  | "max_validation_attempts"
  /** column name */
  | "referrer_code"
  /** column name */
  | "suspicious_count"
  /** column name */
  | "suspicious_percentage"
  /** column name */
  | "total_referrals"
  /** column name */
  | "unique_ips";

/** aggregate stddev on columns */
export interface ReferrerRiskMetricsStddevFields {
  readonly active_days?: Maybe<Scalars["Float"]["output"]>;
  readonly high_attempt_instances?: Maybe<Scalars["Float"]["output"]>;
  readonly max_validation_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_count?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_percentage?: Maybe<Scalars["Float"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface ReferrerRiskMetricsStddevPopFields {
  readonly active_days?: Maybe<Scalars["Float"]["output"]>;
  readonly high_attempt_instances?: Maybe<Scalars["Float"]["output"]>;
  readonly max_validation_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_count?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_percentage?: Maybe<Scalars["Float"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface ReferrerRiskMetricsStddevSampFields {
  readonly active_days?: Maybe<Scalars["Float"]["output"]>;
  readonly high_attempt_instances?: Maybe<Scalars["Float"]["output"]>;
  readonly max_validation_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_count?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_percentage?: Maybe<Scalars["Float"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "referrer_risk_metrics" */
export interface ReferrerRiskMetricsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ReferrerRiskMetricsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ReferrerRiskMetricsStreamCursorValueInput {
  readonly active_days?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly high_attempt_instances?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly max_validation_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  readonly referrer_code?: InputMaybe<Scalars["String"]["input"]>;
  readonly suspicious_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly suspicious_percentage?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly total_referrals?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly unique_ips?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** aggregate sum on columns */
export interface ReferrerRiskMetricsSumFields {
  readonly active_days?: Maybe<Scalars["bigint"]["output"]>;
  readonly high_attempt_instances?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_validation_attempts?: Maybe<Scalars["Int"]["output"]>;
  readonly suspicious_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly suspicious_percentage?: Maybe<Scalars["numeric"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["bigint"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate var_pop on columns */
export interface ReferrerRiskMetricsVarPopFields {
  readonly active_days?: Maybe<Scalars["Float"]["output"]>;
  readonly high_attempt_instances?: Maybe<Scalars["Float"]["output"]>;
  readonly max_validation_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_count?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_percentage?: Maybe<Scalars["Float"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface ReferrerRiskMetricsVarSampFields {
  readonly active_days?: Maybe<Scalars["Float"]["output"]>;
  readonly high_attempt_instances?: Maybe<Scalars["Float"]["output"]>;
  readonly max_validation_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_count?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_percentage?: Maybe<Scalars["Float"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface ReferrerRiskMetricsVarianceFields {
  readonly active_days?: Maybe<Scalars["Float"]["output"]>;
  readonly high_attempt_instances?: Maybe<Scalars["Float"]["output"]>;
  readonly max_validation_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_count?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_percentage?: Maybe<Scalars["Float"]["output"]>;
  readonly total_referrals?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "research" */
export interface Research {
  readonly abstract?: Maybe<Scalars["String"]["output"]>;
  readonly abstract_url: Scalars["String"]["output"];
  readonly affiliations?: Maybe<Scalars["jsonb"]["output"]>;
  readonly authors?: Maybe<Scalars["jsonb"]["output"]>;
  readonly category?: Maybe<Scalars["String"]["output"]>;
  readonly comments?: Maybe<Scalars["String"]["output"]>;
  /** An object relationship */
  readonly content: Contents;
  readonly content_status: Scalars["content_status"]["output"];
  readonly created_at: Scalars["timestamptz"]["output"];
  readonly doi_url?: Maybe<Scalars["String"]["output"]>;
  readonly figure_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly has_embedding?: Maybe<Scalars["Boolean"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  readonly is_flagged: Scalars["Boolean"]["output"];
  readonly keywords?: Maybe<Scalars["String"]["output"]>;
  readonly month?: Maybe<Scalars["String"]["output"]>;
  readonly page_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly pdf_url?: Maybe<Scalars["String"]["output"]>;
  readonly published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly published_in?: Maybe<Scalars["String"]["output"]>;
  /** An object relationship */
  readonly research_embedding?: Maybe<ResearchEmbeddings>;
  readonly summary?: Maybe<Scalars["String"]["output"]>;
  readonly table_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly version?: Maybe<Scalars["smallint"]["output"]>;
  readonly 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 interface ResearchAggregate {
  readonly aggregate?: Maybe<ResearchAggregateFields>;
  readonly nodes: ReadonlyArray<Research>;
}

/** aggregate fields of "research" */
export interface ResearchAggregateFields {
  readonly avg?: Maybe<ResearchAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ResearchMaxFields>;
  readonly min?: Maybe<ResearchMinFields>;
  readonly stddev?: Maybe<ResearchStddevFields>;
  readonly stddev_pop?: Maybe<ResearchStddevPopFields>;
  readonly stddev_samp?: Maybe<ResearchStddevSampFields>;
  readonly sum?: Maybe<ResearchSumFields>;
  readonly var_pop?: Maybe<ResearchVarPopFields>;
  readonly var_samp?: Maybe<ResearchVarSampFields>;
  readonly variance?: Maybe<ResearchVarianceFields>;
}

/** aggregate fields of "research" */
export type ResearchAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ResearchSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export interface ResearchAppendInput {
  readonly affiliations?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly authors?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** aggregate avg on columns */
export interface ResearchAvgFields {
  readonly figure_count?: Maybe<Scalars["Float"]["output"]>;
  readonly page_count?: Maybe<Scalars["Float"]["output"]>;
  readonly table_count?: Maybe<Scalars["Float"]["output"]>;
  readonly version?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "research". All fields are combined with a logical 'AND'. */
export interface ResearchBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ResearchBoolExp>>;
  readonly _not?: InputMaybe<ResearchBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ResearchBoolExp>>;
  readonly abstract?: InputMaybe<StringComparisonExp>;
  readonly abstract_url?: InputMaybe<StringComparisonExp>;
  readonly affiliations?: InputMaybe<JsonbComparisonExp>;
  readonly authors?: InputMaybe<JsonbComparisonExp>;
  readonly category?: InputMaybe<StringComparisonExp>;
  readonly comments?: InputMaybe<StringComparisonExp>;
  readonly content?: InputMaybe<ContentsBoolExp>;
  readonly content_status?: InputMaybe<ContentStatusComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly doi_url?: InputMaybe<StringComparisonExp>;
  readonly figure_count?: InputMaybe<SmallintComparisonExp>;
  readonly has_embedding?: InputMaybe<BooleanComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly is_flagged?: InputMaybe<BooleanComparisonExp>;
  readonly keywords?: InputMaybe<StringComparisonExp>;
  readonly month?: InputMaybe<StringComparisonExp>;
  readonly page_count?: InputMaybe<SmallintComparisonExp>;
  readonly pdf_url?: InputMaybe<StringComparisonExp>;
  readonly published_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly published_in?: InputMaybe<StringComparisonExp>;
  readonly research_embedding?: InputMaybe<ResearchEmbeddingsBoolExp>;
  readonly summary?: InputMaybe<StringComparisonExp>;
  readonly table_count?: InputMaybe<SmallintComparisonExp>;
  readonly title?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly version?: InputMaybe<SmallintComparisonExp>;
  readonly year?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "research" */
export type ResearchConstraint =
  /** unique or primary key constraint on columns "pdf_url" */
  | "research_pdf_url_key"
  /** unique or primary key constraint on columns "id" */
  | "research_pkey"
  /** unique or primary key constraint on columns "abstract_url" */
  | "research_url_key";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface ResearchDeleteAtPathInput {
  readonly affiliations?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
  readonly authors?: InputMaybe<ReadonlyArray<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 interface ResearchDeleteElemInput {
  readonly affiliations?: InputMaybe<Scalars["Int"]["input"]>;
  readonly authors?: InputMaybe<Scalars["Int"]["input"]>;
}

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export interface ResearchDeleteKeyInput {
  readonly affiliations?: InputMaybe<Scalars["String"]["input"]>;
  readonly authors?: InputMaybe<Scalars["String"]["input"]>;
}

/** columns and relationships of "research_embeddings" */
export interface ResearchEmbeddings {
  readonly chunk: Scalars["String"]["output"];
  readonly created_at?: Maybe<Scalars["timestamp"]["output"]>;
  readonly embedding?: Maybe<Scalars["vector"]["output"]>;
  /** An object relationship */
  readonly embedding_review?: Maybe<EmbeddingReviews>;
  readonly embedding_review_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly id: Scalars["Int"]["output"];
  readonly is_flagged?: Maybe<Scalars["Boolean"]["output"]>;
  /** An object relationship */
  readonly research: Research;
  readonly research_id: Scalars["uuid"]["output"];
  readonly updated_at: Scalars["timestamptz"]["output"];
  readonly url?: Maybe<Scalars["String"]["output"]>;
}

/** aggregated selection of "research_embeddings" */
export interface ResearchEmbeddingsAggregate {
  readonly aggregate?: Maybe<ResearchEmbeddingsAggregateFields>;
  readonly nodes: ReadonlyArray<ResearchEmbeddings>;
}

export interface ResearchEmbeddingsAggregateBoolExp {
  readonly bool_and?: InputMaybe<ResearchEmbeddingsAggregateBoolExpBoolAnd>;
  readonly bool_or?: InputMaybe<ResearchEmbeddingsAggregateBoolExpBoolOr>;
  readonly count?: InputMaybe<ResearchEmbeddingsAggregateBoolExpCount>;
}

export interface ResearchEmbeddingsAggregateBoolExpBoolAnd {
  readonly arguments: ResearchEmbeddingsSelectColumnResearchEmbeddingsAggregateBoolExpBoolAndArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ResearchEmbeddingsBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface ResearchEmbeddingsAggregateBoolExpBoolOr {
  readonly arguments: ResearchEmbeddingsSelectColumnResearchEmbeddingsAggregateBoolExpBoolOrArgumentsColumns;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ResearchEmbeddingsBoolExp>;
  readonly predicate: BooleanComparisonExp;
}

export interface ResearchEmbeddingsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<
    ReadonlyArray<ResearchEmbeddingsSelectColumn>
  >;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ResearchEmbeddingsBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "research_embeddings" */
export interface ResearchEmbeddingsAggregateFields {
  readonly avg?: Maybe<ResearchEmbeddingsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ResearchEmbeddingsMaxFields>;
  readonly min?: Maybe<ResearchEmbeddingsMinFields>;
  readonly stddev?: Maybe<ResearchEmbeddingsStddevFields>;
  readonly stddev_pop?: Maybe<ResearchEmbeddingsStddevPopFields>;
  readonly stddev_samp?: Maybe<ResearchEmbeddingsStddevSampFields>;
  readonly sum?: Maybe<ResearchEmbeddingsSumFields>;
  readonly var_pop?: Maybe<ResearchEmbeddingsVarPopFields>;
  readonly var_samp?: Maybe<ResearchEmbeddingsVarSampFields>;
  readonly variance?: Maybe<ResearchEmbeddingsVarianceFields>;
}

/** aggregate fields of "research_embeddings" */
export type ResearchEmbeddingsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ResearchEmbeddingsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "research_embeddings" */
export interface ResearchEmbeddingsAggregateOrderBy {
  readonly avg?: InputMaybe<ResearchEmbeddingsAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<ResearchEmbeddingsMaxOrderBy>;
  readonly min?: InputMaybe<ResearchEmbeddingsMinOrderBy>;
  readonly stddev?: InputMaybe<ResearchEmbeddingsStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<ResearchEmbeddingsStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<ResearchEmbeddingsStddevSampOrderBy>;
  readonly sum?: InputMaybe<ResearchEmbeddingsSumOrderBy>;
  readonly var_pop?: InputMaybe<ResearchEmbeddingsVarPopOrderBy>;
  readonly var_samp?: InputMaybe<ResearchEmbeddingsVarSampOrderBy>;
  readonly variance?: InputMaybe<ResearchEmbeddingsVarianceOrderBy>;
}

/** input type for inserting array relation for remote table "research_embeddings" */
export interface ResearchEmbeddingsArrRelInsertInput {
  readonly data: ReadonlyArray<ResearchEmbeddingsInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<ResearchEmbeddingsOnConflict>;
}

/** aggregate avg on columns */
export interface ResearchEmbeddingsAvgFields {
  readonly embedding_review_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "research_embeddings" */
export interface ResearchEmbeddingsAvgOrderBy {
  readonly embedding_review_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "research_embeddings". All fields are combined with a logical 'AND'. */
export interface ResearchEmbeddingsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ResearchEmbeddingsBoolExp>>;
  readonly _not?: InputMaybe<ResearchEmbeddingsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ResearchEmbeddingsBoolExp>>;
  readonly chunk?: InputMaybe<StringComparisonExp>;
  readonly created_at?: InputMaybe<TimestampComparisonExp>;
  readonly embedding?: InputMaybe<VectorComparisonExp>;
  readonly embedding_review?: InputMaybe<EmbeddingReviewsBoolExp>;
  readonly embedding_review_id?: InputMaybe<BigintComparisonExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly is_flagged?: InputMaybe<BooleanComparisonExp>;
  readonly research?: InputMaybe<ResearchBoolExp>;
  readonly research_id?: InputMaybe<UuidComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly url?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "research_embeddings" */
export type ResearchEmbeddingsConstraint =
  /** unique or primary key constraint on columns "id" */
  | "research_embeddings_id_key"
  /** unique or primary key constraint on columns "id" */
  | "research_embeddings_pkey"
  /** unique or primary key constraint on columns "research_id" */
  | "research_embeddings_research_id_key";

/** input type for incrementing numeric columns in table "research_embeddings" */
export interface ResearchEmbeddingsIncInput {
  readonly embedding_review_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "research_embeddings" */
export interface ResearchEmbeddingsInsertInput {
  readonly chunk?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  readonly embedding?: InputMaybe<Scalars["vector"]["input"]>;
  readonly embedding_review?: InputMaybe<EmbeddingReviewsObjRelInsertInput>;
  readonly embedding_review_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly is_flagged?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly research?: InputMaybe<ResearchObjRelInsertInput>;
  readonly research_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate max on columns */
export interface ResearchEmbeddingsMaxFields {
  readonly chunk?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamp"]["output"]>;
  readonly embedding_review_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly research_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly url?: Maybe<Scalars["String"]["output"]>;
}

/** order by max() on columns of table "research_embeddings" */
export interface ResearchEmbeddingsMaxOrderBy {
  readonly chunk?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly embedding_review_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly research_id?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly url?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface ResearchEmbeddingsMinFields {
  readonly chunk?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamp"]["output"]>;
  readonly embedding_review_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly research_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly url?: Maybe<Scalars["String"]["output"]>;
}

/** order by min() on columns of table "research_embeddings" */
export interface ResearchEmbeddingsMinOrderBy {
  readonly chunk?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly embedding_review_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly research_id?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly url?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "research_embeddings" */
export interface ResearchEmbeddingsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<ResearchEmbeddings>;
}

/** input type for inserting object relation for remote table "research_embeddings" */
export interface ResearchEmbeddingsObjRelInsertInput {
  readonly data: ResearchEmbeddingsInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<ResearchEmbeddingsOnConflict>;
}

/** on_conflict condition type for table "research_embeddings" */
export interface ResearchEmbeddingsOnConflict {
  readonly constraint: ResearchEmbeddingsConstraint;
  readonly update_columns: ReadonlyArray<ResearchEmbeddingsUpdateColumn>;
  readonly where?: InputMaybe<ResearchEmbeddingsBoolExp>;
}

/** Ordering options when selecting data from "research_embeddings". */
export interface ResearchEmbeddingsOrderBy {
  readonly chunk?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly embedding?: InputMaybe<OrderBy>;
  readonly embedding_review?: InputMaybe<EmbeddingReviewsOrderBy>;
  readonly embedding_review_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly is_flagged?: InputMaybe<OrderBy>;
  readonly research?: InputMaybe<ResearchOrderBy>;
  readonly research_id?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly url?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: research_embeddings */
export interface ResearchEmbeddingsPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** select columns of table "research_embeddings" */
export type ResearchEmbeddingsSelectColumn =
  /** column name */
  | "chunk"
  /** column name */
  | "created_at"
  /** column name */
  | "embedding"
  /** column name */
  | "embedding_review_id"
  /** column name */
  | "id"
  /** column name */
  | "is_flagged"
  /** column name */
  | "research_id"
  /** column name */
  | "updated_at"
  /** column name */
  | "url";

/** select "research_embeddings_aggregate_bool_exp_bool_and_arguments_columns" columns of table "research_embeddings" */
export type ResearchEmbeddingsSelectColumnResearchEmbeddingsAggregateBoolExpBoolAndArgumentsColumns =
  /** column name */
  "is_flagged";

/** select "research_embeddings_aggregate_bool_exp_bool_or_arguments_columns" columns of table "research_embeddings" */
export type ResearchEmbeddingsSelectColumnResearchEmbeddingsAggregateBoolExpBoolOrArgumentsColumns =
  /** column name */
  "is_flagged";

/** input type for updating data in table "research_embeddings" */
export interface ResearchEmbeddingsSetInput {
  readonly chunk?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  readonly embedding?: InputMaybe<Scalars["vector"]["input"]>;
  readonly embedding_review_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly is_flagged?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly research_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate stddev on columns */
export interface ResearchEmbeddingsStddevFields {
  readonly embedding_review_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "research_embeddings" */
export interface ResearchEmbeddingsStddevOrderBy {
  readonly embedding_review_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface ResearchEmbeddingsStddevPopFields {
  readonly embedding_review_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "research_embeddings" */
export interface ResearchEmbeddingsStddevPopOrderBy {
  readonly embedding_review_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface ResearchEmbeddingsStddevSampFields {
  readonly embedding_review_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "research_embeddings" */
export interface ResearchEmbeddingsStddevSampOrderBy {
  readonly embedding_review_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "research_embeddings" */
export interface ResearchEmbeddingsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ResearchEmbeddingsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ResearchEmbeddingsStreamCursorValueInput {
  readonly chunk?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamp"]["input"]>;
  readonly embedding?: InputMaybe<Scalars["vector"]["input"]>;
  readonly embedding_review_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly is_flagged?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly research_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface ResearchEmbeddingsSumFields {
  readonly embedding_review_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
}

/** order by sum() on columns of table "research_embeddings" */
export interface ResearchEmbeddingsSumOrderBy {
  readonly embedding_review_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** update columns of table "research_embeddings" */
export type ResearchEmbeddingsUpdateColumn =
  /** column name */
  | "chunk"
  /** column name */
  | "created_at"
  /** column name */
  | "embedding"
  /** column name */
  | "embedding_review_id"
  /** column name */
  | "id"
  /** column name */
  | "is_flagged"
  /** column name */
  | "research_id"
  /** column name */
  | "updated_at"
  /** column name */
  | "url";

export interface ResearchEmbeddingsUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<ResearchEmbeddingsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<ResearchEmbeddingsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: ResearchEmbeddingsBoolExp;
}

/** aggregate var_pop on columns */
export interface ResearchEmbeddingsVarPopFields {
  readonly embedding_review_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "research_embeddings" */
export interface ResearchEmbeddingsVarPopOrderBy {
  readonly embedding_review_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface ResearchEmbeddingsVarSampFields {
  readonly embedding_review_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "research_embeddings" */
export interface ResearchEmbeddingsVarSampOrderBy {
  readonly embedding_review_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface ResearchEmbeddingsVarianceFields {
  readonly embedding_review_id?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "research_embeddings" */
export interface ResearchEmbeddingsVarianceOrderBy {
  readonly embedding_review_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
}

/** input type for incrementing numeric columns in table "research" */
export interface ResearchIncInput {
  readonly figure_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly page_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly table_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly version?: InputMaybe<Scalars["smallint"]["input"]>;
}

/** input type for inserting data into table "research" */
export interface ResearchInsertInput {
  readonly abstract?: InputMaybe<Scalars["String"]["input"]>;
  readonly abstract_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly affiliations?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly authors?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly category?: InputMaybe<Scalars["String"]["input"]>;
  readonly comments?: InputMaybe<Scalars["String"]["input"]>;
  readonly content?: InputMaybe<ContentsObjRelInsertInput>;
  readonly content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly doi_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly figure_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly has_embedding?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly is_flagged?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly keywords?: InputMaybe<Scalars["String"]["input"]>;
  readonly month?: InputMaybe<Scalars["String"]["input"]>;
  readonly page_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly pdf_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly published_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly published_in?: InputMaybe<Scalars["String"]["input"]>;
  readonly research_embedding?: InputMaybe<ResearchEmbeddingsObjRelInsertInput>;
  readonly summary?: InputMaybe<Scalars["String"]["input"]>;
  readonly table_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly version?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly year?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate max on columns */
export interface ResearchMaxFields {
  readonly abstract?: Maybe<Scalars["String"]["output"]>;
  readonly abstract_url?: Maybe<Scalars["String"]["output"]>;
  readonly category?: Maybe<Scalars["String"]["output"]>;
  readonly comments?: Maybe<Scalars["String"]["output"]>;
  readonly content_status?: Maybe<Scalars["content_status"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly doi_url?: Maybe<Scalars["String"]["output"]>;
  readonly figure_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly keywords?: Maybe<Scalars["String"]["output"]>;
  readonly month?: Maybe<Scalars["String"]["output"]>;
  readonly page_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly pdf_url?: Maybe<Scalars["String"]["output"]>;
  readonly published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly published_in?: Maybe<Scalars["String"]["output"]>;
  readonly summary?: Maybe<Scalars["String"]["output"]>;
  readonly table_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly version?: Maybe<Scalars["smallint"]["output"]>;
  readonly year?: Maybe<Scalars["String"]["output"]>;
}

/** aggregate min on columns */
export interface ResearchMinFields {
  readonly abstract?: Maybe<Scalars["String"]["output"]>;
  readonly abstract_url?: Maybe<Scalars["String"]["output"]>;
  readonly category?: Maybe<Scalars["String"]["output"]>;
  readonly comments?: Maybe<Scalars["String"]["output"]>;
  readonly content_status?: Maybe<Scalars["content_status"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly doi_url?: Maybe<Scalars["String"]["output"]>;
  readonly figure_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly keywords?: Maybe<Scalars["String"]["output"]>;
  readonly month?: Maybe<Scalars["String"]["output"]>;
  readonly page_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly pdf_url?: Maybe<Scalars["String"]["output"]>;
  readonly published_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly published_in?: Maybe<Scalars["String"]["output"]>;
  readonly summary?: Maybe<Scalars["String"]["output"]>;
  readonly table_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly title?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly version?: Maybe<Scalars["smallint"]["output"]>;
  readonly year?: Maybe<Scalars["String"]["output"]>;
}

/** response of any mutation on the table "research" */
export interface ResearchMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Research>;
}

/** input type for inserting object relation for remote table "research" */
export interface ResearchObjRelInsertInput {
  readonly data: ResearchInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<ResearchOnConflict>;
}

/** on_conflict condition type for table "research" */
export interface ResearchOnConflict {
  readonly constraint: ResearchConstraint;
  readonly update_columns: ReadonlyArray<ResearchUpdateColumn>;
  readonly where?: InputMaybe<ResearchBoolExp>;
}

/** Ordering options when selecting data from "research". */
export interface ResearchOrderBy {
  readonly abstract?: InputMaybe<OrderBy>;
  readonly abstract_url?: InputMaybe<OrderBy>;
  readonly affiliations?: InputMaybe<OrderBy>;
  readonly authors?: InputMaybe<OrderBy>;
  readonly category?: InputMaybe<OrderBy>;
  readonly comments?: InputMaybe<OrderBy>;
  readonly content?: InputMaybe<ContentsOrderBy>;
  readonly content_status?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly doi_url?: InputMaybe<OrderBy>;
  readonly figure_count?: InputMaybe<OrderBy>;
  readonly has_embedding?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly is_flagged?: InputMaybe<OrderBy>;
  readonly keywords?: InputMaybe<OrderBy>;
  readonly month?: InputMaybe<OrderBy>;
  readonly page_count?: InputMaybe<OrderBy>;
  readonly pdf_url?: InputMaybe<OrderBy>;
  readonly published_at?: InputMaybe<OrderBy>;
  readonly published_in?: InputMaybe<OrderBy>;
  readonly research_embedding?: InputMaybe<ResearchEmbeddingsOrderBy>;
  readonly summary?: InputMaybe<OrderBy>;
  readonly table_count?: InputMaybe<OrderBy>;
  readonly title?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly version?: InputMaybe<OrderBy>;
  readonly year?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: research */
export interface ResearchPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** prepend existing jsonb value of filtered columns with new jsonb value */
export interface ResearchPrependInput {
  readonly affiliations?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly authors?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** select columns of table "research" */
export type ResearchSelectColumn =
  /** column name */
  | "abstract"
  /** column name */
  | "abstract_url"
  /** column name */
  | "affiliations"
  /** column name */
  | "authors"
  /** column name */
  | "category"
  /** column name */
  | "comments"
  /** column name */
  | "content_status"
  /** column name */
  | "created_at"
  /** column name */
  | "doi_url"
  /** column name */
  | "figure_count"
  /** column name */
  | "has_embedding"
  /** column name */
  | "id"
  /** column name */
  | "is_flagged"
  /** column name */
  | "keywords"
  /** column name */
  | "month"
  /** column name */
  | "page_count"
  /** column name */
  | "pdf_url"
  /** column name */
  | "published_at"
  /** column name */
  | "published_in"
  /** column name */
  | "summary"
  /** column name */
  | "table_count"
  /** column name */
  | "title"
  /** column name */
  | "updated_at"
  /** column name */
  | "version"
  /** column name */
  | "year";

/** input type for updating data in table "research" */
export interface ResearchSetInput {
  readonly abstract?: InputMaybe<Scalars["String"]["input"]>;
  readonly abstract_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly affiliations?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly authors?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly category?: InputMaybe<Scalars["String"]["input"]>;
  readonly comments?: InputMaybe<Scalars["String"]["input"]>;
  readonly content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly doi_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly figure_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly has_embedding?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly is_flagged?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly keywords?: InputMaybe<Scalars["String"]["input"]>;
  readonly month?: InputMaybe<Scalars["String"]["input"]>;
  readonly page_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly pdf_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly published_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly published_in?: InputMaybe<Scalars["String"]["input"]>;
  readonly summary?: InputMaybe<Scalars["String"]["input"]>;
  readonly table_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly version?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly year?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate stddev on columns */
export interface ResearchStddevFields {
  readonly figure_count?: Maybe<Scalars["Float"]["output"]>;
  readonly page_count?: Maybe<Scalars["Float"]["output"]>;
  readonly table_count?: Maybe<Scalars["Float"]["output"]>;
  readonly version?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface ResearchStddevPopFields {
  readonly figure_count?: Maybe<Scalars["Float"]["output"]>;
  readonly page_count?: Maybe<Scalars["Float"]["output"]>;
  readonly table_count?: Maybe<Scalars["Float"]["output"]>;
  readonly version?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface ResearchStddevSampFields {
  readonly figure_count?: Maybe<Scalars["Float"]["output"]>;
  readonly page_count?: Maybe<Scalars["Float"]["output"]>;
  readonly table_count?: Maybe<Scalars["Float"]["output"]>;
  readonly version?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "research" */
export interface ResearchStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ResearchStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ResearchStreamCursorValueInput {
  readonly abstract?: InputMaybe<Scalars["String"]["input"]>;
  readonly abstract_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly affiliations?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly authors?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly category?: InputMaybe<Scalars["String"]["input"]>;
  readonly comments?: InputMaybe<Scalars["String"]["input"]>;
  readonly content_status?: InputMaybe<Scalars["content_status"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly doi_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly figure_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly has_embedding?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly is_flagged?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly keywords?: InputMaybe<Scalars["String"]["input"]>;
  readonly month?: InputMaybe<Scalars["String"]["input"]>;
  readonly page_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly pdf_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly published_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly published_in?: InputMaybe<Scalars["String"]["input"]>;
  readonly summary?: InputMaybe<Scalars["String"]["input"]>;
  readonly table_count?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly title?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly version?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly year?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface ResearchSumFields {
  readonly figure_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly page_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly table_count?: Maybe<Scalars["smallint"]["output"]>;
  readonly version?: Maybe<Scalars["smallint"]["output"]>;
}

/** update columns of table "research" */
export type ResearchUpdateColumn =
  /** column name */
  | "abstract"
  /** column name */
  | "abstract_url"
  /** column name */
  | "affiliations"
  /** column name */
  | "authors"
  /** column name */
  | "category"
  /** column name */
  | "comments"
  /** column name */
  | "content_status"
  /** column name */
  | "created_at"
  /** column name */
  | "doi_url"
  /** column name */
  | "figure_count"
  /** column name */
  | "has_embedding"
  /** column name */
  | "id"
  /** column name */
  | "is_flagged"
  /** column name */
  | "keywords"
  /** column name */
  | "month"
  /** column name */
  | "page_count"
  /** column name */
  | "pdf_url"
  /** column name */
  | "published_at"
  /** column name */
  | "published_in"
  /** column name */
  | "summary"
  /** column name */
  | "table_count"
  /** column name */
  | "title"
  /** column name */
  | "updated_at"
  /** column name */
  | "version"
  /** column name */
  | "year";

export interface ResearchUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<ResearchAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<ResearchDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<ResearchDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<ResearchIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<ResearchPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<ResearchSetInput>;
  /** filter the rows which have to be updated */
  readonly where: ResearchBoolExp;
}

/** aggregate var_pop on columns */
export interface ResearchVarPopFields {
  readonly figure_count?: Maybe<Scalars["Float"]["output"]>;
  readonly page_count?: Maybe<Scalars["Float"]["output"]>;
  readonly table_count?: Maybe<Scalars["Float"]["output"]>;
  readonly version?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface ResearchVarSampFields {
  readonly figure_count?: Maybe<Scalars["Float"]["output"]>;
  readonly page_count?: Maybe<Scalars["Float"]["output"]>;
  readonly table_count?: Maybe<Scalars["Float"]["output"]>;
  readonly version?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface ResearchVarianceFields {
  readonly figure_count?: Maybe<Scalars["Float"]["output"]>;
  readonly page_count?: Maybe<Scalars["Float"]["output"]>;
  readonly table_count?: Maybe<Scalars["Float"]["output"]>;
  readonly version?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "responses" */
export interface Responses {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly downvotes?: Maybe<Scalars["Int"]["output"]>;
  readonly id: Scalars["bigint"]["output"];
  readonly output: Scalars["String"]["output"];
  /** An object relationship */
  readonly search: Searches;
  readonly search_id: Scalars["bigint"]["output"];
  readonly upvotes?: Maybe<Scalars["Int"]["output"]>;
}

/** aggregated selection of "responses" */
export interface ResponsesAggregate {
  readonly aggregate?: Maybe<ResponsesAggregateFields>;
  readonly nodes: ReadonlyArray<Responses>;
}

export interface ResponsesAggregateBoolExp {
  readonly count?: InputMaybe<ResponsesAggregateBoolExpCount>;
}

export interface ResponsesAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<ResponsesSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<ResponsesBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "responses" */
export interface ResponsesAggregateFields {
  readonly avg?: Maybe<ResponsesAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ResponsesMaxFields>;
  readonly min?: Maybe<ResponsesMinFields>;
  readonly stddev?: Maybe<ResponsesStddevFields>;
  readonly stddev_pop?: Maybe<ResponsesStddevPopFields>;
  readonly stddev_samp?: Maybe<ResponsesStddevSampFields>;
  readonly sum?: Maybe<ResponsesSumFields>;
  readonly var_pop?: Maybe<ResponsesVarPopFields>;
  readonly var_samp?: Maybe<ResponsesVarSampFields>;
  readonly variance?: Maybe<ResponsesVarianceFields>;
}

/** aggregate fields of "responses" */
export type ResponsesAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ResponsesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "responses" */
export interface ResponsesAggregateOrderBy {
  readonly avg?: InputMaybe<ResponsesAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<ResponsesMaxOrderBy>;
  readonly min?: InputMaybe<ResponsesMinOrderBy>;
  readonly stddev?: InputMaybe<ResponsesStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<ResponsesStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<ResponsesStddevSampOrderBy>;
  readonly sum?: InputMaybe<ResponsesSumOrderBy>;
  readonly var_pop?: InputMaybe<ResponsesVarPopOrderBy>;
  readonly var_samp?: InputMaybe<ResponsesVarSampOrderBy>;
  readonly variance?: InputMaybe<ResponsesVarianceOrderBy>;
}

/** input type for inserting array relation for remote table "responses" */
export interface ResponsesArrRelInsertInput {
  readonly data: ReadonlyArray<ResponsesInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<ResponsesOnConflict>;
}

/** aggregate avg on columns */
export interface ResponsesAvgFields {
  readonly downvotes?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly search_id?: Maybe<Scalars["Float"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "responses" */
export interface ResponsesAvgOrderBy {
  readonly downvotes?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly search_id?: InputMaybe<OrderBy>;
  readonly upvotes?: InputMaybe<OrderBy>;
}

/** Boolean expression to filter rows from the table "responses". All fields are combined with a logical 'AND'. */
export interface ResponsesBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ResponsesBoolExp>>;
  readonly _not?: InputMaybe<ResponsesBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ResponsesBoolExp>>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly downvotes?: InputMaybe<IntComparisonExp>;
  readonly id?: InputMaybe<BigintComparisonExp>;
  readonly output?: InputMaybe<StringComparisonExp>;
  readonly search?: InputMaybe<SearchesBoolExp>;
  readonly search_id?: InputMaybe<BigintComparisonExp>;
  readonly upvotes?: InputMaybe<IntComparisonExp>;
}

/** unique or primary key constraints on table "responses" */
export type ResponsesConstraint =
  /** unique or primary key constraint on columns "id" */
  | "responses_id_key"
  /** unique or primary key constraint on columns "id" */
  | "responses_pkey";

/** input type for incrementing numeric columns in table "responses" */
export interface ResponsesIncInput {
  readonly downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly search_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly upvotes?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "responses" */
export interface ResponsesInsertInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly output?: InputMaybe<Scalars["String"]["input"]>;
  readonly search?: InputMaybe<SearchesObjRelInsertInput>;
  readonly search_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly upvotes?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate max on columns */
export interface ResponsesMaxFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly downvotes?: Maybe<Scalars["Int"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly output?: Maybe<Scalars["String"]["output"]>;
  readonly search_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Int"]["output"]>;
}

/** order by max() on columns of table "responses" */
export interface ResponsesMaxOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly downvotes?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly output?: InputMaybe<OrderBy>;
  readonly search_id?: InputMaybe<OrderBy>;
  readonly upvotes?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface ResponsesMinFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly downvotes?: Maybe<Scalars["Int"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly output?: Maybe<Scalars["String"]["output"]>;
  readonly search_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Int"]["output"]>;
}

/** order by min() on columns of table "responses" */
export interface ResponsesMinOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly downvotes?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly output?: InputMaybe<OrderBy>;
  readonly search_id?: InputMaybe<OrderBy>;
  readonly upvotes?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "responses" */
export interface ResponsesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Responses>;
}

/** on_conflict condition type for table "responses" */
export interface ResponsesOnConflict {
  readonly constraint: ResponsesConstraint;
  readonly update_columns: ReadonlyArray<ResponsesUpdateColumn>;
  readonly where?: InputMaybe<ResponsesBoolExp>;
}

/** Ordering options when selecting data from "responses". */
export interface ResponsesOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly downvotes?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly output?: InputMaybe<OrderBy>;
  readonly search?: InputMaybe<SearchesOrderBy>;
  readonly search_id?: InputMaybe<OrderBy>;
  readonly upvotes?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: responses */
export interface ResponsesPkColumnsInput {
  readonly id: Scalars["bigint"]["input"];
}

/** select columns of table "responses" */
export type ResponsesSelectColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "downvotes"
  /** column name */
  | "id"
  /** column name */
  | "output"
  /** column name */
  | "search_id"
  /** column name */
  | "upvotes";

/** input type for updating data in table "responses" */
export interface ResponsesSetInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly output?: InputMaybe<Scalars["String"]["input"]>;
  readonly search_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly upvotes?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate stddev on columns */
export interface ResponsesStddevFields {
  readonly downvotes?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly search_id?: Maybe<Scalars["Float"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "responses" */
export interface ResponsesStddevOrderBy {
  readonly downvotes?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly search_id?: InputMaybe<OrderBy>;
  readonly upvotes?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface ResponsesStddevPopFields {
  readonly downvotes?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly search_id?: Maybe<Scalars["Float"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "responses" */
export interface ResponsesStddevPopOrderBy {
  readonly downvotes?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly search_id?: InputMaybe<OrderBy>;
  readonly upvotes?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface ResponsesStddevSampFields {
  readonly downvotes?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly search_id?: Maybe<Scalars["Float"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "responses" */
export interface ResponsesStddevSampOrderBy {
  readonly downvotes?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly search_id?: InputMaybe<OrderBy>;
  readonly upvotes?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "responses" */
export interface ResponsesStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ResponsesStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ResponsesStreamCursorValueInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly downvotes?: InputMaybe<Scalars["Int"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly output?: InputMaybe<Scalars["String"]["input"]>;
  readonly search_id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly upvotes?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate sum on columns */
export interface ResponsesSumFields {
  readonly downvotes?: Maybe<Scalars["Int"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly search_id?: Maybe<Scalars["bigint"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Int"]["output"]>;
}

/** order by sum() on columns of table "responses" */
export interface ResponsesSumOrderBy {
  readonly downvotes?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly search_id?: InputMaybe<OrderBy>;
  readonly upvotes?: InputMaybe<OrderBy>;
}

/** update columns of table "responses" */
export type ResponsesUpdateColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "downvotes"
  /** column name */
  | "id"
  /** column name */
  | "output"
  /** column name */
  | "search_id"
  /** column name */
  | "upvotes";

export interface ResponsesUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<ResponsesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<ResponsesSetInput>;
  /** filter the rows which have to be updated */
  readonly where: ResponsesBoolExp;
}

/** aggregate var_pop on columns */
export interface ResponsesVarPopFields {
  readonly downvotes?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly search_id?: Maybe<Scalars["Float"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "responses" */
export interface ResponsesVarPopOrderBy {
  readonly downvotes?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly search_id?: InputMaybe<OrderBy>;
  readonly upvotes?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface ResponsesVarSampFields {
  readonly downvotes?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly search_id?: Maybe<Scalars["Float"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "responses" */
export interface ResponsesVarSampOrderBy {
  readonly downvotes?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly search_id?: InputMaybe<OrderBy>;
  readonly upvotes?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface ResponsesVarianceFields {
  readonly downvotes?: Maybe<Scalars["Float"]["output"]>;
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly search_id?: Maybe<Scalars["Float"]["output"]>;
  readonly upvotes?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "responses" */
export interface ResponsesVarianceOrderBy {
  readonly downvotes?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly search_id?: InputMaybe<OrderBy>;
  readonly upvotes?: InputMaybe<OrderBy>;
}

/** columns and relationships of "role_hierarchy" */
export interface RoleHierarchy {
  readonly child_role: Scalars["app_role_enum"]["output"];
  readonly parent_role: Scalars["app_role_enum"]["output"];
}

/** aggregated selection of "role_hierarchy" */
export interface RoleHierarchyAggregate {
  readonly aggregate?: Maybe<RoleHierarchyAggregateFields>;
  readonly nodes: ReadonlyArray<RoleHierarchy>;
}

/** aggregate fields of "role_hierarchy" */
export interface RoleHierarchyAggregateFields {
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<RoleHierarchyMaxFields>;
  readonly min?: Maybe<RoleHierarchyMinFields>;
}

/** aggregate fields of "role_hierarchy" */
export type RoleHierarchyAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<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 interface RoleHierarchyBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<RoleHierarchyBoolExp>>;
  readonly _not?: InputMaybe<RoleHierarchyBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<RoleHierarchyBoolExp>>;
  readonly child_role?: InputMaybe<AppRoleEnumComparisonExp>;
  readonly parent_role?: InputMaybe<AppRoleEnumComparisonExp>;
}

/** unique or primary key constraints on table "role_hierarchy" */
export type RoleHierarchyConstraint =
  /** unique or primary key constraint on columns "parent_role", "child_role" */
  "role_hierarchy_pkey";

/** input type for inserting data into table "role_hierarchy" */
export interface RoleHierarchyInsertInput {
  readonly child_role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  readonly parent_role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
}

/** aggregate max on columns */
export interface RoleHierarchyMaxFields {
  readonly child_role?: Maybe<Scalars["app_role_enum"]["output"]>;
  readonly parent_role?: Maybe<Scalars["app_role_enum"]["output"]>;
}

/** aggregate min on columns */
export interface RoleHierarchyMinFields {
  readonly child_role?: Maybe<Scalars["app_role_enum"]["output"]>;
  readonly parent_role?: Maybe<Scalars["app_role_enum"]["output"]>;
}

/** response of any mutation on the table "role_hierarchy" */
export interface RoleHierarchyMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<RoleHierarchy>;
}

/** on_conflict condition type for table "role_hierarchy" */
export interface RoleHierarchyOnConflict {
  readonly constraint: RoleHierarchyConstraint;
  readonly update_columns: ReadonlyArray<RoleHierarchyUpdateColumn>;
  readonly where?: InputMaybe<RoleHierarchyBoolExp>;
}

/** Ordering options when selecting data from "role_hierarchy". */
export interface RoleHierarchyOrderBy {
  readonly child_role?: InputMaybe<OrderBy>;
  readonly parent_role?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: role_hierarchy */
export interface RoleHierarchyPkColumnsInput {
  readonly child_role: Scalars["app_role_enum"]["input"];
  readonly parent_role: Scalars["app_role_enum"]["input"];
}

/** select columns of table "role_hierarchy" */
export type RoleHierarchySelectColumn =
  /** column name */
  | "child_role"
  /** column name */
  | "parent_role";

/** input type for updating data in table "role_hierarchy" */
export interface RoleHierarchySetInput {
  readonly child_role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  readonly parent_role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
}

/** Streaming cursor of the table "role_hierarchy" */
export interface RoleHierarchyStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: RoleHierarchyStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface RoleHierarchyStreamCursorValueInput {
  readonly child_role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  readonly parent_role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
}

/** update columns of table "role_hierarchy" */
export type RoleHierarchyUpdateColumn =
  /** column name */
  | "child_role"
  /** column name */
  | "parent_role";

export interface RoleHierarchyUpdates {
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<RoleHierarchySetInput>;
  /** filter the rows which have to be updated */
  readonly where: RoleHierarchyBoolExp;
}

/** columns and relationships of "role_permissions" */
export interface RolePermissions {
  readonly cached_permissions?: Maybe<Scalars["jsonb"]["output"]>;
  readonly conditions?: Maybe<Scalars["jsonb"]["output"]>;
  readonly id: Scalars["Int"]["output"];
  readonly inherit_from?: Maybe<
    ReadonlyArray<Scalars["app_role_enum"]["output"]>
  >;
  readonly last_updated?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly permissions?: Maybe<Scalars["jsonb"]["output"]>;
  readonly role: Scalars["app_role_enum"]["output"];
  readonly 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 interface RolePermissionsAggregate {
  readonly aggregate?: Maybe<RolePermissionsAggregateFields>;
  readonly nodes: ReadonlyArray<RolePermissions>;
}

/** aggregate fields of "role_permissions" */
export interface RolePermissionsAggregateFields {
  readonly avg?: Maybe<RolePermissionsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<RolePermissionsMaxFields>;
  readonly min?: Maybe<RolePermissionsMinFields>;
  readonly stddev?: Maybe<RolePermissionsStddevFields>;
  readonly stddev_pop?: Maybe<RolePermissionsStddevPopFields>;
  readonly stddev_samp?: Maybe<RolePermissionsStddevSampFields>;
  readonly sum?: Maybe<RolePermissionsSumFields>;
  readonly var_pop?: Maybe<RolePermissionsVarPopFields>;
  readonly var_samp?: Maybe<RolePermissionsVarSampFields>;
  readonly variance?: Maybe<RolePermissionsVarianceFields>;
}

/** aggregate fields of "role_permissions" */
export type RolePermissionsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<RolePermissionsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export interface RolePermissionsAppendInput {
  readonly cached_permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly conditions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** aggregate avg on columns */
export interface RolePermissionsAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "role_permissions". All fields are combined with a logical 'AND'. */
export interface RolePermissionsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<RolePermissionsBoolExp>>;
  readonly _not?: InputMaybe<RolePermissionsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<RolePermissionsBoolExp>>;
  readonly cached_permissions?: InputMaybe<JsonbComparisonExp>;
  readonly conditions?: InputMaybe<JsonbComparisonExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly inherit_from?: InputMaybe<AppRoleEnumArrayComparisonExp>;
  readonly last_updated?: InputMaybe<TimestamptzComparisonExp>;
  readonly permissions?: InputMaybe<JsonbComparisonExp>;
  readonly role?: InputMaybe<AppRoleEnumComparisonExp>;
  readonly table_name?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "role_permissions" */
export type RolePermissionsConstraint =
  /** unique or primary key constraint on columns "id" */
  "role_permissions_pkey";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface RolePermissionsDeleteAtPathInput {
  readonly cached_permissions?: InputMaybe<
    ReadonlyArray<Scalars["String"]["input"]>
  >;
  readonly conditions?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
  readonly permissions?: InputMaybe<ReadonlyArray<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 interface RolePermissionsDeleteElemInput {
  readonly cached_permissions?: InputMaybe<Scalars["Int"]["input"]>;
  readonly conditions?: InputMaybe<Scalars["Int"]["input"]>;
  readonly permissions?: InputMaybe<Scalars["Int"]["input"]>;
}

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export interface RolePermissionsDeleteKeyInput {
  readonly cached_permissions?: InputMaybe<Scalars["String"]["input"]>;
  readonly conditions?: InputMaybe<Scalars["String"]["input"]>;
  readonly permissions?: InputMaybe<Scalars["String"]["input"]>;
}

/** input type for incrementing numeric columns in table "role_permissions" */
export interface RolePermissionsIncInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "role_permissions" */
export interface RolePermissionsInsertInput {
  readonly cached_permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly conditions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly inherit_from?: InputMaybe<
    ReadonlyArray<Scalars["app_role_enum"]["input"]>
  >;
  readonly last_updated?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  readonly table_name?: InputMaybe<Scalars["String"]["input"]>;
}

/** columns and relationships of "role_permissions_materialized" */
export interface RolePermissionsMaterialized {
  readonly last_updated?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly permissions: Scalars["jsonb"]["output"];
  readonly 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 interface RolePermissionsMaterializedAggregate {
  readonly aggregate?: Maybe<RolePermissionsMaterializedAggregateFields>;
  readonly nodes: ReadonlyArray<RolePermissionsMaterialized>;
}

/** aggregate fields of "role_permissions_materialized" */
export interface RolePermissionsMaterializedAggregateFields {
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<RolePermissionsMaterializedMaxFields>;
  readonly min?: Maybe<RolePermissionsMaterializedMinFields>;
}

/** aggregate fields of "role_permissions_materialized" */
export type RolePermissionsMaterializedAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<RolePermissionsMaterializedSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export interface RolePermissionsMaterializedAppendInput {
  readonly 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 interface RolePermissionsMaterializedBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<RolePermissionsMaterializedBoolExp>>;
  readonly _not?: InputMaybe<RolePermissionsMaterializedBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<RolePermissionsMaterializedBoolExp>>;
  readonly last_updated?: InputMaybe<TimestamptzComparisonExp>;
  readonly permissions?: InputMaybe<JsonbComparisonExp>;
  readonly role?: InputMaybe<AppRoleEnumComparisonExp>;
}

/** unique or primary key constraints on table "role_permissions_materialized" */
export type RolePermissionsMaterializedConstraint =
  /** unique or primary key constraint on columns "role" */
  "role_permissions_materialized_pkey";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface RolePermissionsMaterializedDeleteAtPathInput {
  readonly permissions?: InputMaybe<ReadonlyArray<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 interface RolePermissionsMaterializedDeleteElemInput {
  readonly permissions?: InputMaybe<Scalars["Int"]["input"]>;
}

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

/** input type for inserting data into table "role_permissions_materialized" */
export interface RolePermissionsMaterializedInsertInput {
  readonly last_updated?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
}

/** aggregate max on columns */
export interface RolePermissionsMaterializedMaxFields {
  readonly last_updated?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly role?: Maybe<Scalars["app_role_enum"]["output"]>;
}

/** aggregate min on columns */
export interface RolePermissionsMaterializedMinFields {
  readonly last_updated?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly role?: Maybe<Scalars["app_role_enum"]["output"]>;
}

/** response of any mutation on the table "role_permissions_materialized" */
export interface RolePermissionsMaterializedMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<RolePermissionsMaterialized>;
}

/** on_conflict condition type for table "role_permissions_materialized" */
export interface RolePermissionsMaterializedOnConflict {
  readonly constraint: RolePermissionsMaterializedConstraint;
  readonly update_columns: ReadonlyArray<RolePermissionsMaterializedUpdateColumn>;
  readonly where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
}

/** Ordering options when selecting data from "role_permissions_materialized". */
export interface RolePermissionsMaterializedOrderBy {
  readonly last_updated?: InputMaybe<OrderBy>;
  readonly permissions?: InputMaybe<OrderBy>;
  readonly role?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: role_permissions_materialized */
export interface RolePermissionsMaterializedPkColumnsInput {
  readonly role: Scalars["app_role_enum"]["input"];
}

/** prepend existing jsonb value of filtered columns with new jsonb value */
export interface RolePermissionsMaterializedPrependInput {
  readonly permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** select columns of table "role_permissions_materialized" */
export type RolePermissionsMaterializedSelectColumn =
  /** column name */
  | "last_updated"
  /** column name */
  | "permissions"
  /** column name */
  | "role";

/** input type for updating data in table "role_permissions_materialized" */
export interface RolePermissionsMaterializedSetInput {
  readonly last_updated?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
}

/** Streaming cursor of the table "role_permissions_materialized" */
export interface RolePermissionsMaterializedStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: RolePermissionsMaterializedStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface RolePermissionsMaterializedStreamCursorValueInput {
  readonly last_updated?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
}

/** update columns of table "role_permissions_materialized" */
export type RolePermissionsMaterializedUpdateColumn =
  /** column name */
  | "last_updated"
  /** column name */
  | "permissions"
  /** column name */
  | "role";

export interface RolePermissionsMaterializedUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<RolePermissionsMaterializedAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<RolePermissionsMaterializedDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<RolePermissionsMaterializedDeleteKeyInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<RolePermissionsMaterializedPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<RolePermissionsMaterializedSetInput>;
  /** filter the rows which have to be updated */
  readonly where: RolePermissionsMaterializedBoolExp;
}

/** aggregate max on columns */
export interface RolePermissionsMaxFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly inherit_from?: Maybe<
    ReadonlyArray<Scalars["app_role_enum"]["output"]>
  >;
  readonly last_updated?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly role?: Maybe<Scalars["app_role_enum"]["output"]>;
  readonly table_name?: Maybe<Scalars["String"]["output"]>;
}

/** aggregate min on columns */
export interface RolePermissionsMinFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly inherit_from?: Maybe<
    ReadonlyArray<Scalars["app_role_enum"]["output"]>
  >;
  readonly last_updated?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly role?: Maybe<Scalars["app_role_enum"]["output"]>;
  readonly table_name?: Maybe<Scalars["String"]["output"]>;
}

/** response of any mutation on the table "role_permissions" */
export interface RolePermissionsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<RolePermissions>;
}

/** on_conflict condition type for table "role_permissions" */
export interface RolePermissionsOnConflict {
  readonly constraint: RolePermissionsConstraint;
  readonly update_columns: ReadonlyArray<RolePermissionsUpdateColumn>;
  readonly where?: InputMaybe<RolePermissionsBoolExp>;
}

/** Ordering options when selecting data from "role_permissions". */
export interface RolePermissionsOrderBy {
  readonly cached_permissions?: InputMaybe<OrderBy>;
  readonly conditions?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly inherit_from?: InputMaybe<OrderBy>;
  readonly last_updated?: InputMaybe<OrderBy>;
  readonly permissions?: InputMaybe<OrderBy>;
  readonly role?: InputMaybe<OrderBy>;
  readonly table_name?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: role_permissions */
export interface RolePermissionsPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** prepend existing jsonb value of filtered columns with new jsonb value */
export interface RolePermissionsPrependInput {
  readonly cached_permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly conditions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** select columns of table "role_permissions" */
export type RolePermissionsSelectColumn =
  /** column name */
  | "cached_permissions"
  /** column name */
  | "conditions"
  /** column name */
  | "id"
  /** column name */
  | "inherit_from"
  /** column name */
  | "last_updated"
  /** column name */
  | "permissions"
  /** column name */
  | "role"
  /** column name */
  | "table_name";

/** input type for updating data in table "role_permissions" */
export interface RolePermissionsSetInput {
  readonly cached_permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly conditions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly inherit_from?: InputMaybe<
    ReadonlyArray<Scalars["app_role_enum"]["input"]>
  >;
  readonly last_updated?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  readonly table_name?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate stddev on columns */
export interface RolePermissionsStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface RolePermissionsStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface RolePermissionsStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "role_permissions" */
export interface RolePermissionsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: RolePermissionsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface RolePermissionsStreamCursorValueInput {
  readonly cached_permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly conditions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly inherit_from?: InputMaybe<
    ReadonlyArray<Scalars["app_role_enum"]["input"]>
  >;
  readonly last_updated?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly permissions?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  readonly table_name?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface RolePermissionsSumFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "role_permissions" */
export type RolePermissionsUpdateColumn =
  /** column name */
  | "cached_permissions"
  /** column name */
  | "conditions"
  /** column name */
  | "id"
  /** column name */
  | "inherit_from"
  /** column name */
  | "last_updated"
  /** column name */
  | "permissions"
  /** column name */
  | "role"
  /** column name */
  | "table_name";

export interface RolePermissionsUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<RolePermissionsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<RolePermissionsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<RolePermissionsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<RolePermissionsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<RolePermissionsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<RolePermissionsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: RolePermissionsBoolExp;
}

/** aggregate var_pop on columns */
export interface RolePermissionsVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface RolePermissionsVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface RolePermissionsVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "scoring_weights" */
export interface ScoringWeights {
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  readonly name: Scalars["String"]["output"];
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly weight: Scalars["float8"]["output"];
}

/** aggregated selection of "scoring_weights" */
export interface ScoringWeightsAggregate {
  readonly aggregate?: Maybe<ScoringWeightsAggregateFields>;
  readonly nodes: ReadonlyArray<ScoringWeights>;
}

/** aggregate fields of "scoring_weights" */
export interface ScoringWeightsAggregateFields {
  readonly avg?: Maybe<ScoringWeightsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<ScoringWeightsMaxFields>;
  readonly min?: Maybe<ScoringWeightsMinFields>;
  readonly stddev?: Maybe<ScoringWeightsStddevFields>;
  readonly stddev_pop?: Maybe<ScoringWeightsStddevPopFields>;
  readonly stddev_samp?: Maybe<ScoringWeightsStddevSampFields>;
  readonly sum?: Maybe<ScoringWeightsSumFields>;
  readonly var_pop?: Maybe<ScoringWeightsVarPopFields>;
  readonly var_samp?: Maybe<ScoringWeightsVarSampFields>;
  readonly variance?: Maybe<ScoringWeightsVarianceFields>;
}

/** aggregate fields of "scoring_weights" */
export type ScoringWeightsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<ScoringWeightsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface ScoringWeightsAvgFields {
  readonly weight?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "scoring_weights". All fields are combined with a logical 'AND'. */
export interface ScoringWeightsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<ScoringWeightsBoolExp>>;
  readonly _not?: InputMaybe<ScoringWeightsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<ScoringWeightsBoolExp>>;
  readonly description?: InputMaybe<StringComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly name?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly weight?: InputMaybe<Float8ComparisonExp>;
}

/** unique or primary key constraints on table "scoring_weights" */
export type ScoringWeightsConstraint =
  /** unique or primary key constraint on columns "name" */
  | "scoring_weights_name_key"
  /** unique or primary key constraint on columns "id" */
  | "scoring_weights_pkey";

/** input type for incrementing numeric columns in table "scoring_weights" */
export interface ScoringWeightsIncInput {
  readonly weight?: InputMaybe<Scalars["float8"]["input"]>;
}

/** input type for inserting data into table "scoring_weights" */
export interface ScoringWeightsInsertInput {
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly weight?: InputMaybe<Scalars["float8"]["input"]>;
}

/** aggregate max on columns */
export interface ScoringWeightsMaxFields {
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly weight?: Maybe<Scalars["float8"]["output"]>;
}

/** aggregate min on columns */
export interface ScoringWeightsMinFields {
  readonly description?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly weight?: Maybe<Scalars["float8"]["output"]>;
}

/** response of any mutation on the table "scoring_weights" */
export interface ScoringWeightsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<ScoringWeights>;
}

/** on_conflict condition type for table "scoring_weights" */
export interface ScoringWeightsOnConflict {
  readonly constraint: ScoringWeightsConstraint;
  readonly update_columns: ReadonlyArray<ScoringWeightsUpdateColumn>;
  readonly where?: InputMaybe<ScoringWeightsBoolExp>;
}

/** Ordering options when selecting data from "scoring_weights". */
export interface ScoringWeightsOrderBy {
  readonly description?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly name?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly weight?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: scoring_weights */
export interface ScoringWeightsPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** select columns of table "scoring_weights" */
export type ScoringWeightsSelectColumn =
  /** column name */
  | "description"
  /** column name */
  | "id"
  /** column name */
  | "name"
  /** column name */
  | "updated_at"
  /** column name */
  | "weight";

/** input type for updating data in table "scoring_weights" */
export interface ScoringWeightsSetInput {
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly weight?: InputMaybe<Scalars["float8"]["input"]>;
}

/** aggregate stddev on columns */
export interface ScoringWeightsStddevFields {
  readonly weight?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface ScoringWeightsStddevPopFields {
  readonly weight?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface ScoringWeightsStddevSampFields {
  readonly weight?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "scoring_weights" */
export interface ScoringWeightsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: ScoringWeightsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface ScoringWeightsStreamCursorValueInput {
  readonly description?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly weight?: InputMaybe<Scalars["float8"]["input"]>;
}

/** aggregate sum on columns */
export interface ScoringWeightsSumFields {
  readonly weight?: Maybe<Scalars["float8"]["output"]>;
}

/** update columns of table "scoring_weights" */
export type ScoringWeightsUpdateColumn =
  /** column name */
  | "description"
  /** column name */
  | "id"
  /** column name */
  | "name"
  /** column name */
  | "updated_at"
  /** column name */
  | "weight";

export interface ScoringWeightsUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<ScoringWeightsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<ScoringWeightsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: ScoringWeightsBoolExp;
}

/** aggregate var_pop on columns */
export interface ScoringWeightsVarPopFields {
  readonly weight?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface ScoringWeightsVarSampFields {
  readonly weight?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface ScoringWeightsVarianceFields {
  readonly weight?: Maybe<Scalars["Float"]["output"]>;
}

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

/** columns and relationships of "searches" */
export interface Searches {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly embedding?: Maybe<Scalars["vector"]["output"]>;
  readonly id: Scalars["bigint"]["output"];
  readonly input: Scalars["String"]["output"];
  /** An array relationship */
  readonly responses: ReadonlyArray<Responses>;
  /** An aggregate relationship */
  readonly responses_aggregate: ResponsesAggregate;
  readonly tokens_used?: Maybe<Scalars["smallint"]["output"]>;
  readonly user_ids?: Maybe<ReadonlyArray<Scalars["uuid"]["output"]>>;
}

/** columns and relationships of "searches" */
export type SearchesResponsesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResponsesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResponsesOrderBy>>;
  where?: InputMaybe<ResponsesBoolExp>;
};

/** columns and relationships of "searches" */
export type SearchesResponsesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResponsesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResponsesOrderBy>>;
  where?: InputMaybe<ResponsesBoolExp>;
};

/** aggregated selection of "searches" */
export interface SearchesAggregate {
  readonly aggregate?: Maybe<SearchesAggregateFields>;
  readonly nodes: ReadonlyArray<Searches>;
}

/** aggregate fields of "searches" */
export interface SearchesAggregateFields {
  readonly avg?: Maybe<SearchesAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<SearchesMaxFields>;
  readonly min?: Maybe<SearchesMinFields>;
  readonly stddev?: Maybe<SearchesStddevFields>;
  readonly stddev_pop?: Maybe<SearchesStddevPopFields>;
  readonly stddev_samp?: Maybe<SearchesStddevSampFields>;
  readonly sum?: Maybe<SearchesSumFields>;
  readonly var_pop?: Maybe<SearchesVarPopFields>;
  readonly var_samp?: Maybe<SearchesVarSampFields>;
  readonly variance?: Maybe<SearchesVarianceFields>;
}

/** aggregate fields of "searches" */
export type SearchesAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<SearchesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface SearchesAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly tokens_used?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "searches". All fields are combined with a logical 'AND'. */
export interface SearchesBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<SearchesBoolExp>>;
  readonly _not?: InputMaybe<SearchesBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<SearchesBoolExp>>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly embedding?: InputMaybe<VectorComparisonExp>;
  readonly id?: InputMaybe<BigintComparisonExp>;
  readonly input?: InputMaybe<StringComparisonExp>;
  readonly responses?: InputMaybe<ResponsesBoolExp>;
  readonly responses_aggregate?: InputMaybe<ResponsesAggregateBoolExp>;
  readonly tokens_used?: InputMaybe<SmallintComparisonExp>;
  readonly user_ids?: InputMaybe<UuidArrayComparisonExp>;
}

/** unique or primary key constraints on table "searches" */
export type SearchesConstraint =
  /** unique or primary key constraint on columns "input" */
  | "searches_input_key"
  /** unique or primary key constraint on columns "id" */
  | "searches_pkey";

/** input type for incrementing numeric columns in table "searches" */
export interface SearchesIncInput {
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly tokens_used?: InputMaybe<Scalars["smallint"]["input"]>;
}

/** input type for inserting data into table "searches" */
export interface SearchesInsertInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly embedding?: InputMaybe<Scalars["vector"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly input?: InputMaybe<Scalars["String"]["input"]>;
  readonly responses?: InputMaybe<ResponsesArrRelInsertInput>;
  readonly tokens_used?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly user_ids?: InputMaybe<ReadonlyArray<Scalars["uuid"]["input"]>>;
}

/** aggregate max on columns */
export interface SearchesMaxFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly input?: Maybe<Scalars["String"]["output"]>;
  readonly tokens_used?: Maybe<Scalars["smallint"]["output"]>;
  readonly user_ids?: Maybe<ReadonlyArray<Scalars["uuid"]["output"]>>;
}

/** aggregate min on columns */
export interface SearchesMinFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly input?: Maybe<Scalars["String"]["output"]>;
  readonly tokens_used?: Maybe<Scalars["smallint"]["output"]>;
  readonly user_ids?: Maybe<ReadonlyArray<Scalars["uuid"]["output"]>>;
}

/** response of any mutation on the table "searches" */
export interface SearchesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Searches>;
}

/** input type for inserting object relation for remote table "searches" */
export interface SearchesObjRelInsertInput {
  readonly data: SearchesInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<SearchesOnConflict>;
}

/** on_conflict condition type for table "searches" */
export interface SearchesOnConflict {
  readonly constraint: SearchesConstraint;
  readonly update_columns: ReadonlyArray<SearchesUpdateColumn>;
  readonly where?: InputMaybe<SearchesBoolExp>;
}

/** Ordering options when selecting data from "searches". */
export interface SearchesOrderBy {
  readonly created_at?: InputMaybe<OrderBy>;
  readonly embedding?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly input?: InputMaybe<OrderBy>;
  readonly responses_aggregate?: InputMaybe<ResponsesAggregateOrderBy>;
  readonly tokens_used?: InputMaybe<OrderBy>;
  readonly user_ids?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: searches */
export interface SearchesPkColumnsInput {
  readonly id: Scalars["bigint"]["input"];
}

/** select columns of table "searches" */
export type SearchesSelectColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "embedding"
  /** column name */
  | "id"
  /** column name */
  | "input"
  /** column name */
  | "tokens_used"
  /** column name */
  | "user_ids";

/** input type for updating data in table "searches" */
export interface SearchesSetInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly embedding?: InputMaybe<Scalars["vector"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly input?: InputMaybe<Scalars["String"]["input"]>;
  readonly tokens_used?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly user_ids?: InputMaybe<ReadonlyArray<Scalars["uuid"]["input"]>>;
}

/** aggregate stddev on columns */
export interface SearchesStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly tokens_used?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface SearchesStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly tokens_used?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface SearchesStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly tokens_used?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "searches" */
export interface SearchesStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: SearchesStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface SearchesStreamCursorValueInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly embedding?: InputMaybe<Scalars["vector"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly input?: InputMaybe<Scalars["String"]["input"]>;
  readonly tokens_used?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly user_ids?: InputMaybe<ReadonlyArray<Scalars["uuid"]["input"]>>;
}

/** aggregate sum on columns */
export interface SearchesSumFields {
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly tokens_used?: Maybe<Scalars["smallint"]["output"]>;
}

/** update columns of table "searches" */
export type SearchesUpdateColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "embedding"
  /** column name */
  | "id"
  /** column name */
  | "input"
  /** column name */
  | "tokens_used"
  /** column name */
  | "user_ids";

export interface SearchesUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<SearchesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<SearchesSetInput>;
  /** filter the rows which have to be updated */
  readonly where: SearchesBoolExp;
}

/** aggregate var_pop on columns */
export interface SearchesVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly tokens_used?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface SearchesVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly tokens_used?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface SearchesVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly tokens_used?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "security_metrics" */
export interface SecurityMetrics {
  readonly high_attempt_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_attempts?: Maybe<Scalars["Int"]["output"]>;
  readonly suspicious_attempts?: Maybe<Scalars["bigint"]["output"]>;
  readonly time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly total_attempts?: Maybe<Scalars["bigint"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["bigint"]["output"]>;
  readonly unique_referrers?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregated selection of "security_metrics" */
export interface SecurityMetricsAggregate {
  readonly aggregate?: Maybe<SecurityMetricsAggregateFields>;
  readonly nodes: ReadonlyArray<SecurityMetrics>;
}

/** aggregate fields of "security_metrics" */
export interface SecurityMetricsAggregateFields {
  readonly avg?: Maybe<SecurityMetricsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<SecurityMetricsMaxFields>;
  readonly min?: Maybe<SecurityMetricsMinFields>;
  readonly stddev?: Maybe<SecurityMetricsStddevFields>;
  readonly stddev_pop?: Maybe<SecurityMetricsStddevPopFields>;
  readonly stddev_samp?: Maybe<SecurityMetricsStddevSampFields>;
  readonly sum?: Maybe<SecurityMetricsSumFields>;
  readonly var_pop?: Maybe<SecurityMetricsVarPopFields>;
  readonly var_samp?: Maybe<SecurityMetricsVarSampFields>;
  readonly variance?: Maybe<SecurityMetricsVarianceFields>;
}

/** aggregate fields of "security_metrics" */
export type SecurityMetricsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<SecurityMetricsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface SecurityMetricsAvgFields {
  readonly high_attempt_count?: Maybe<Scalars["Float"]["output"]>;
  readonly max_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly total_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["Float"]["output"]>;
  readonly 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 interface SecurityMetricsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<SecurityMetricsBoolExp>>;
  readonly _not?: InputMaybe<SecurityMetricsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<SecurityMetricsBoolExp>>;
  readonly high_attempt_count?: InputMaybe<BigintComparisonExp>;
  readonly max_attempts?: InputMaybe<IntComparisonExp>;
  readonly suspicious_attempts?: InputMaybe<BigintComparisonExp>;
  readonly time_bucket?: InputMaybe<TimestamptzComparisonExp>;
  readonly total_attempts?: InputMaybe<BigintComparisonExp>;
  readonly unique_ips?: InputMaybe<BigintComparisonExp>;
  readonly unique_referrers?: InputMaybe<BigintComparisonExp>;
}

/** aggregate max on columns */
export interface SecurityMetricsMaxFields {
  readonly high_attempt_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_attempts?: Maybe<Scalars["Int"]["output"]>;
  readonly suspicious_attempts?: Maybe<Scalars["bigint"]["output"]>;
  readonly time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly total_attempts?: Maybe<Scalars["bigint"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["bigint"]["output"]>;
  readonly unique_referrers?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate min on columns */
export interface SecurityMetricsMinFields {
  readonly high_attempt_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_attempts?: Maybe<Scalars["Int"]["output"]>;
  readonly suspicious_attempts?: Maybe<Scalars["bigint"]["output"]>;
  readonly time_bucket?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly total_attempts?: Maybe<Scalars["bigint"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["bigint"]["output"]>;
  readonly unique_referrers?: Maybe<Scalars["bigint"]["output"]>;
}

/** Ordering options when selecting data from "security_metrics". */
export interface SecurityMetricsOrderBy {
  readonly high_attempt_count?: InputMaybe<OrderBy>;
  readonly max_attempts?: InputMaybe<OrderBy>;
  readonly suspicious_attempts?: InputMaybe<OrderBy>;
  readonly time_bucket?: InputMaybe<OrderBy>;
  readonly total_attempts?: InputMaybe<OrderBy>;
  readonly unique_ips?: InputMaybe<OrderBy>;
  readonly unique_referrers?: InputMaybe<OrderBy>;
}

/** select columns of table "security_metrics" */
export type SecurityMetricsSelectColumn =
  /** column name */
  | "high_attempt_count"
  /** column name */
  | "max_attempts"
  /** column name */
  | "suspicious_attempts"
  /** column name */
  | "time_bucket"
  /** column name */
  | "total_attempts"
  /** column name */
  | "unique_ips"
  /** column name */
  | "unique_referrers";

/** aggregate stddev on columns */
export interface SecurityMetricsStddevFields {
  readonly high_attempt_count?: Maybe<Scalars["Float"]["output"]>;
  readonly max_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly total_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_referrers?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface SecurityMetricsStddevPopFields {
  readonly high_attempt_count?: Maybe<Scalars["Float"]["output"]>;
  readonly max_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly total_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_referrers?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface SecurityMetricsStddevSampFields {
  readonly high_attempt_count?: Maybe<Scalars["Float"]["output"]>;
  readonly max_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly total_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_referrers?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "security_metrics" */
export interface SecurityMetricsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: SecurityMetricsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface SecurityMetricsStreamCursorValueInput {
  readonly high_attempt_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly max_attempts?: InputMaybe<Scalars["Int"]["input"]>;
  readonly suspicious_attempts?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly time_bucket?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly total_attempts?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly unique_ips?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly unique_referrers?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** aggregate sum on columns */
export interface SecurityMetricsSumFields {
  readonly high_attempt_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_attempts?: Maybe<Scalars["Int"]["output"]>;
  readonly suspicious_attempts?: Maybe<Scalars["bigint"]["output"]>;
  readonly total_attempts?: Maybe<Scalars["bigint"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["bigint"]["output"]>;
  readonly unique_referrers?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate var_pop on columns */
export interface SecurityMetricsVarPopFields {
  readonly high_attempt_count?: Maybe<Scalars["Float"]["output"]>;
  readonly max_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly total_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_referrers?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface SecurityMetricsVarSampFields {
  readonly high_attempt_count?: Maybe<Scalars["Float"]["output"]>;
  readonly max_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly total_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_referrers?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface SecurityMetricsVarianceFields {
  readonly high_attempt_count?: Maybe<Scalars["Float"]["output"]>;
  readonly max_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly suspicious_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly total_attempts?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_ips?: Maybe<Scalars["Float"]["output"]>;
  readonly unique_referrers?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "slow_query_patterns" */
export interface SlowQueryPatterns {
  readonly avg_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly first_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly query_id?: Maybe<Scalars["String"]["output"]>;
}

/** aggregated selection of "slow_query_patterns" */
export interface SlowQueryPatternsAggregate {
  readonly aggregate?: Maybe<SlowQueryPatternsAggregateFields>;
  readonly nodes: ReadonlyArray<SlowQueryPatterns>;
}

/** aggregate fields of "slow_query_patterns" */
export interface SlowQueryPatternsAggregateFields {
  readonly avg?: Maybe<SlowQueryPatternsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<SlowQueryPatternsMaxFields>;
  readonly min?: Maybe<SlowQueryPatternsMinFields>;
  readonly stddev?: Maybe<SlowQueryPatternsStddevFields>;
  readonly stddev_pop?: Maybe<SlowQueryPatternsStddevPopFields>;
  readonly stddev_samp?: Maybe<SlowQueryPatternsStddevSampFields>;
  readonly sum?: Maybe<SlowQueryPatternsSumFields>;
  readonly var_pop?: Maybe<SlowQueryPatternsVarPopFields>;
  readonly var_samp?: Maybe<SlowQueryPatternsVarSampFields>;
  readonly variance?: Maybe<SlowQueryPatternsVarianceFields>;
}

/** aggregate fields of "slow_query_patterns" */
export type SlowQueryPatternsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<SlowQueryPatternsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface SlowQueryPatternsAvgFields {
  readonly avg_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly 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 interface SlowQueryPatternsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<SlowQueryPatternsBoolExp>>;
  readonly _not?: InputMaybe<SlowQueryPatternsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<SlowQueryPatternsBoolExp>>;
  readonly avg_exec_time?: InputMaybe<Float8ComparisonExp>;
  readonly first_seen?: InputMaybe<TimestamptzComparisonExp>;
  readonly last_seen?: InputMaybe<TimestamptzComparisonExp>;
  readonly max_exec_time?: InputMaybe<Float8ComparisonExp>;
  readonly occurrence_count?: InputMaybe<BigintComparisonExp>;
  readonly query_id?: InputMaybe<StringComparisonExp>;
}

/** aggregate max on columns */
export interface SlowQueryPatternsMaxFields {
  readonly avg_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly first_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly query_id?: Maybe<Scalars["String"]["output"]>;
}

/** aggregate min on columns */
export interface SlowQueryPatternsMinFields {
  readonly avg_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly first_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly query_id?: Maybe<Scalars["String"]["output"]>;
}

/** Ordering options when selecting data from "slow_query_patterns". */
export interface SlowQueryPatternsOrderBy {
  readonly avg_exec_time?: InputMaybe<OrderBy>;
  readonly first_seen?: InputMaybe<OrderBy>;
  readonly last_seen?: InputMaybe<OrderBy>;
  readonly max_exec_time?: InputMaybe<OrderBy>;
  readonly occurrence_count?: InputMaybe<OrderBy>;
  readonly query_id?: InputMaybe<OrderBy>;
}

/** select columns of table "slow_query_patterns" */
export type SlowQueryPatternsSelectColumn =
  /** column name */
  | "avg_exec_time"
  /** column name */
  | "first_seen"
  /** column name */
  | "last_seen"
  /** column name */
  | "max_exec_time"
  /** column name */
  | "occurrence_count"
  /** column name */
  | "query_id";

/** aggregate stddev on columns */
export interface SlowQueryPatternsStddevFields {
  readonly avg_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface SlowQueryPatternsStddevPopFields {
  readonly avg_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface SlowQueryPatternsStddevSampFields {
  readonly avg_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "slow_query_patterns" */
export interface SlowQueryPatternsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: SlowQueryPatternsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface SlowQueryPatternsStreamCursorValueInput {
  readonly avg_exec_time?: InputMaybe<Scalars["float8"]["input"]>;
  readonly first_seen?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly last_seen?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly max_exec_time?: InputMaybe<Scalars["float8"]["input"]>;
  readonly occurrence_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly query_id?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface SlowQueryPatternsSumFields {
  readonly avg_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["float8"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate var_pop on columns */
export interface SlowQueryPatternsVarPopFields {
  readonly avg_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface SlowQueryPatternsVarSampFields {
  readonly avg_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface SlowQueryPatternsVarianceFields {
  readonly avg_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly max_exec_time?: Maybe<Scalars["Float"]["output"]>;
  readonly occurrence_count?: Maybe<Scalars["Float"]["output"]>;
}

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

/** columns and relationships of "social_media" */
export interface SocialMedia {
  /** An array relationship */
  readonly companies: ReadonlyArray<Companies>;
  /** An aggregate relationship */
  readonly companies_aggregate: CompaniesAggregate;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly facebook_url?: Maybe<Scalars["String"]["output"]>;
  readonly id: Scalars["Int"]["output"];
  readonly instagram_url?: Maybe<Scalars["String"]["output"]>;
  readonly linkedin_url?: Maybe<Scalars["String"]["output"]>;
  readonly twitter_url?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly youtube_url?: Maybe<Scalars["String"]["output"]>;
}

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

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

/** aggregated selection of "social_media" */
export interface SocialMediaAggregate {
  readonly aggregate?: Maybe<SocialMediaAggregateFields>;
  readonly nodes: ReadonlyArray<SocialMedia>;
}

/** aggregate fields of "social_media" */
export interface SocialMediaAggregateFields {
  readonly avg?: Maybe<SocialMediaAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<SocialMediaMaxFields>;
  readonly min?: Maybe<SocialMediaMinFields>;
  readonly stddev?: Maybe<SocialMediaStddevFields>;
  readonly stddev_pop?: Maybe<SocialMediaStddevPopFields>;
  readonly stddev_samp?: Maybe<SocialMediaStddevSampFields>;
  readonly sum?: Maybe<SocialMediaSumFields>;
  readonly var_pop?: Maybe<SocialMediaVarPopFields>;
  readonly var_samp?: Maybe<SocialMediaVarSampFields>;
  readonly variance?: Maybe<SocialMediaVarianceFields>;
}

/** aggregate fields of "social_media" */
export type SocialMediaAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<SocialMediaSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface SocialMediaAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "social_media". All fields are combined with a logical 'AND'. */
export interface SocialMediaBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<SocialMediaBoolExp>>;
  readonly _not?: InputMaybe<SocialMediaBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<SocialMediaBoolExp>>;
  readonly companies?: InputMaybe<CompaniesBoolExp>;
  readonly companies_aggregate?: InputMaybe<CompaniesAggregateBoolExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly facebook_url?: InputMaybe<StringComparisonExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly instagram_url?: InputMaybe<StringComparisonExp>;
  readonly linkedin_url?: InputMaybe<StringComparisonExp>;
  readonly twitter_url?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly youtube_url?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "social_media" */
export type SocialMediaConstraint =
  /** unique or primary key constraint on columns "id" */
  "social_media_pkey";

/** input type for incrementing numeric columns in table "social_media" */
export interface SocialMediaIncInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "social_media" */
export interface SocialMediaInsertInput {
  readonly companies?: InputMaybe<CompaniesArrRelInsertInput>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly facebook_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly instagram_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly linkedin_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly twitter_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly youtube_url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate max on columns */
export interface SocialMediaMaxFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly facebook_url?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly instagram_url?: Maybe<Scalars["String"]["output"]>;
  readonly linkedin_url?: Maybe<Scalars["String"]["output"]>;
  readonly twitter_url?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly youtube_url?: Maybe<Scalars["String"]["output"]>;
}

/** aggregate min on columns */
export interface SocialMediaMinFields {
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly facebook_url?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly instagram_url?: Maybe<Scalars["String"]["output"]>;
  readonly linkedin_url?: Maybe<Scalars["String"]["output"]>;
  readonly twitter_url?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly youtube_url?: Maybe<Scalars["String"]["output"]>;
}

/** response of any mutation on the table "social_media" */
export interface SocialMediaMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<SocialMedia>;
}

/** input type for inserting object relation for remote table "social_media" */
export interface SocialMediaObjRelInsertInput {
  readonly data: SocialMediaInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<SocialMediaOnConflict>;
}

/** on_conflict condition type for table "social_media" */
export interface SocialMediaOnConflict {
  readonly constraint: SocialMediaConstraint;
  readonly update_columns: ReadonlyArray<SocialMediaUpdateColumn>;
  readonly where?: InputMaybe<SocialMediaBoolExp>;
}

/** Ordering options when selecting data from "social_media". */
export interface SocialMediaOrderBy {
  readonly companies_aggregate?: InputMaybe<CompaniesAggregateOrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly facebook_url?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly instagram_url?: InputMaybe<OrderBy>;
  readonly linkedin_url?: InputMaybe<OrderBy>;
  readonly twitter_url?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly youtube_url?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: social_media */
export interface SocialMediaPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** select columns of table "social_media" */
export type SocialMediaSelectColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "facebook_url"
  /** column name */
  | "id"
  /** column name */
  | "instagram_url"
  /** column name */
  | "linkedin_url"
  /** column name */
  | "twitter_url"
  /** column name */
  | "updated_at"
  /** column name */
  | "youtube_url";

/** input type for updating data in table "social_media" */
export interface SocialMediaSetInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly facebook_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly instagram_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly linkedin_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly twitter_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly youtube_url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate stddev on columns */
export interface SocialMediaStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface SocialMediaStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface SocialMediaStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "social_media" */
export interface SocialMediaStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: SocialMediaStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface SocialMediaStreamCursorValueInput {
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly facebook_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly instagram_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly linkedin_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly twitter_url?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly youtube_url?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface SocialMediaSumFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "social_media" */
export type SocialMediaUpdateColumn =
  /** column name */
  | "created_at"
  /** column name */
  | "facebook_url"
  /** column name */
  | "id"
  /** column name */
  | "instagram_url"
  /** column name */
  | "linkedin_url"
  /** column name */
  | "twitter_url"
  /** column name */
  | "updated_at"
  /** column name */
  | "youtube_url";

export interface SocialMediaUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<SocialMediaIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<SocialMediaSetInput>;
  /** filter the rows which have to be updated */
  readonly where: SocialMediaBoolExp;
}

/** aggregate var_pop on columns */
export interface SocialMediaVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface SocialMediaVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface SocialMediaVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "spider_metrics" */
export interface SpiderMetrics {
  readonly crawl_id: Scalars["uuid"]["output"];
  readonly id: Scalars["bigint"]["output"];
  /** An object relationship */
  readonly metric_definition?: Maybe<MetricDefinitions>;
  readonly metric_id?: Maybe<Scalars["Int"]["output"]>;
  readonly timestamp: Scalars["timestamptz"]["output"];
  readonly value: Scalars["jsonb"]["output"];
}

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

/** aggregated selection of "spider_metrics" */
export interface SpiderMetricsAggregate {
  readonly aggregate?: Maybe<SpiderMetricsAggregateFields>;
  readonly nodes: ReadonlyArray<SpiderMetrics>;
}

export interface SpiderMetricsAggregateBoolExp {
  readonly count?: InputMaybe<SpiderMetricsAggregateBoolExpCount>;
}

export interface SpiderMetricsAggregateBoolExpCount {
  readonly arguments?: InputMaybe<ReadonlyArray<SpiderMetricsSelectColumn>>;
  readonly distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly filter?: InputMaybe<SpiderMetricsBoolExp>;
  readonly predicate: IntComparisonExp;
}

/** aggregate fields of "spider_metrics" */
export interface SpiderMetricsAggregateFields {
  readonly avg?: Maybe<SpiderMetricsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<SpiderMetricsMaxFields>;
  readonly min?: Maybe<SpiderMetricsMinFields>;
  readonly stddev?: Maybe<SpiderMetricsStddevFields>;
  readonly stddev_pop?: Maybe<SpiderMetricsStddevPopFields>;
  readonly stddev_samp?: Maybe<SpiderMetricsStddevSampFields>;
  readonly sum?: Maybe<SpiderMetricsSumFields>;
  readonly var_pop?: Maybe<SpiderMetricsVarPopFields>;
  readonly var_samp?: Maybe<SpiderMetricsVarSampFields>;
  readonly variance?: Maybe<SpiderMetricsVarianceFields>;
}

/** aggregate fields of "spider_metrics" */
export type SpiderMetricsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<SpiderMetricsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** order by aggregate values of table "spider_metrics" */
export interface SpiderMetricsAggregateOrderBy {
  readonly avg?: InputMaybe<SpiderMetricsAvgOrderBy>;
  readonly count?: InputMaybe<OrderBy>;
  readonly max?: InputMaybe<SpiderMetricsMaxOrderBy>;
  readonly min?: InputMaybe<SpiderMetricsMinOrderBy>;
  readonly stddev?: InputMaybe<SpiderMetricsStddevOrderBy>;
  readonly stddev_pop?: InputMaybe<SpiderMetricsStddevPopOrderBy>;
  readonly stddev_samp?: InputMaybe<SpiderMetricsStddevSampOrderBy>;
  readonly sum?: InputMaybe<SpiderMetricsSumOrderBy>;
  readonly var_pop?: InputMaybe<SpiderMetricsVarPopOrderBy>;
  readonly var_samp?: InputMaybe<SpiderMetricsVarSampOrderBy>;
  readonly variance?: InputMaybe<SpiderMetricsVarianceOrderBy>;
}

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

/** input type for inserting array relation for remote table "spider_metrics" */
export interface SpiderMetricsArrRelInsertInput {
  readonly data: ReadonlyArray<SpiderMetricsInsertInput>;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<SpiderMetricsOnConflict>;
}

/** aggregate avg on columns */
export interface SpiderMetricsAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by avg() on columns of table "spider_metrics" */
export interface SpiderMetricsAvgOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
}

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

/** unique or primary key constraints on table "spider_metrics" */
export type SpiderMetricsConstraint =
  /** unique or primary key constraint on columns "id" */
  "spider_metrics_pkey";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface SpiderMetricsDeleteAtPathInput {
  readonly value?: InputMaybe<ReadonlyArray<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 interface SpiderMetricsDeleteElemInput {
  readonly value?: InputMaybe<Scalars["Int"]["input"]>;
}

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

/** input type for incrementing numeric columns in table "spider_metrics" */
export interface SpiderMetricsIncInput {
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly metric_id?: InputMaybe<Scalars["Int"]["input"]>;
}

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

/** aggregate max on columns */
export interface SpiderMetricsMaxFields {
  readonly crawl_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Int"]["output"]>;
  readonly timestamp?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** order by max() on columns of table "spider_metrics" */
export interface SpiderMetricsMaxOrderBy {
  readonly crawl_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
  readonly timestamp?: InputMaybe<OrderBy>;
}

/** aggregate min on columns */
export interface SpiderMetricsMinFields {
  readonly crawl_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Int"]["output"]>;
  readonly timestamp?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** order by min() on columns of table "spider_metrics" */
export interface SpiderMetricsMinOrderBy {
  readonly crawl_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
  readonly timestamp?: InputMaybe<OrderBy>;
}

/** response of any mutation on the table "spider_metrics" */
export interface SpiderMetricsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<SpiderMetrics>;
}

/** on_conflict condition type for table "spider_metrics" */
export interface SpiderMetricsOnConflict {
  readonly constraint: SpiderMetricsConstraint;
  readonly update_columns: ReadonlyArray<SpiderMetricsUpdateColumn>;
  readonly where?: InputMaybe<SpiderMetricsBoolExp>;
}

/** Ordering options when selecting data from "spider_metrics". */
export interface SpiderMetricsOrderBy {
  readonly crawl_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_definition?: InputMaybe<MetricDefinitionsOrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
  readonly timestamp?: InputMaybe<OrderBy>;
  readonly value?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: spider_metrics */
export interface SpiderMetricsPkColumnsInput {
  readonly id: Scalars["bigint"]["input"];
}

/** prepend existing jsonb value of filtered columns with new jsonb value */
export interface SpiderMetricsPrependInput {
  readonly value?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** select columns of table "spider_metrics" */
export type SpiderMetricsSelectColumn =
  /** column name */
  | "crawl_id"
  /** column name */
  | "id"
  /** column name */
  | "metric_id"
  /** column name */
  | "timestamp"
  /** column name */
  | "value";

/** input type for updating data in table "spider_metrics" */
export interface SpiderMetricsSetInput {
  readonly crawl_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly metric_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly timestamp?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly value?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** aggregate stddev on columns */
export interface SpiderMetricsStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev() on columns of table "spider_metrics" */
export interface SpiderMetricsStddevOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_pop on columns */
export interface SpiderMetricsStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_pop() on columns of table "spider_metrics" */
export interface SpiderMetricsStddevPopOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
}

/** aggregate stddev_samp on columns */
export interface SpiderMetricsStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by stddev_samp() on columns of table "spider_metrics" */
export interface SpiderMetricsStddevSampOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
}

/** Streaming cursor of the table "spider_metrics" */
export interface SpiderMetricsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: SpiderMetricsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface SpiderMetricsStreamCursorValueInput {
  readonly crawl_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly id?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly metric_id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly timestamp?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly value?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** aggregate sum on columns */
export interface SpiderMetricsSumFields {
  readonly id?: Maybe<Scalars["bigint"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Int"]["output"]>;
}

/** order by sum() on columns of table "spider_metrics" */
export interface SpiderMetricsSumOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
}

/** update columns of table "spider_metrics" */
export type SpiderMetricsUpdateColumn =
  /** column name */
  | "crawl_id"
  /** column name */
  | "id"
  /** column name */
  | "metric_id"
  /** column name */
  | "timestamp"
  /** column name */
  | "value";

export interface SpiderMetricsUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<SpiderMetricsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<SpiderMetricsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<SpiderMetricsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<SpiderMetricsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<SpiderMetricsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<SpiderMetricsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: SpiderMetricsBoolExp;
}

/** aggregate var_pop on columns */
export interface SpiderMetricsVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_pop() on columns of table "spider_metrics" */
export interface SpiderMetricsVarPopOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
}

/** aggregate var_samp on columns */
export interface SpiderMetricsVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by var_samp() on columns of table "spider_metrics" */
export interface SpiderMetricsVarSampOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
}

/** aggregate variance on columns */
export interface SpiderMetricsVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
  readonly metric_id?: Maybe<Scalars["Float"]["output"]>;
}

/** order by variance() on columns of table "spider_metrics" */
export interface SpiderMetricsVarianceOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly metric_id?: InputMaybe<OrderBy>;
}

/** columns and relationships of "strapi_migrations" */
export interface StrapiMigrations {
  readonly id: Scalars["Int"]["output"];
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly time?: Maybe<Scalars["timestamp"]["output"]>;
}

/** aggregated selection of "strapi_migrations" */
export interface StrapiMigrationsAggregate {
  readonly aggregate?: Maybe<StrapiMigrationsAggregateFields>;
  readonly nodes: ReadonlyArray<StrapiMigrations>;
}

/** aggregate fields of "strapi_migrations" */
export interface StrapiMigrationsAggregateFields {
  readonly avg?: Maybe<StrapiMigrationsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<StrapiMigrationsMaxFields>;
  readonly min?: Maybe<StrapiMigrationsMinFields>;
  readonly stddev?: Maybe<StrapiMigrationsStddevFields>;
  readonly stddev_pop?: Maybe<StrapiMigrationsStddevPopFields>;
  readonly stddev_samp?: Maybe<StrapiMigrationsStddevSampFields>;
  readonly sum?: Maybe<StrapiMigrationsSumFields>;
  readonly var_pop?: Maybe<StrapiMigrationsVarPopFields>;
  readonly var_samp?: Maybe<StrapiMigrationsVarSampFields>;
  readonly variance?: Maybe<StrapiMigrationsVarianceFields>;
}

/** aggregate fields of "strapi_migrations" */
export type StrapiMigrationsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<StrapiMigrationsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface StrapiMigrationsAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "strapi_migrations". All fields are combined with a logical 'AND'. */
export interface StrapiMigrationsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<StrapiMigrationsBoolExp>>;
  readonly _not?: InputMaybe<StrapiMigrationsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<StrapiMigrationsBoolExp>>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly name?: InputMaybe<StringComparisonExp>;
  readonly time?: InputMaybe<TimestampComparisonExp>;
}

/** unique or primary key constraints on table "strapi_migrations" */
export type StrapiMigrationsConstraint =
  /** unique or primary key constraint on columns "id" */
  "strapi_migrations_pkey";

/** input type for incrementing numeric columns in table "strapi_migrations" */
export interface StrapiMigrationsIncInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "strapi_migrations" */
export interface StrapiMigrationsInsertInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly time?: InputMaybe<Scalars["timestamp"]["input"]>;
}

/** columns and relationships of "strapi_migrations_internal" */
export interface StrapiMigrationsInternal {
  readonly id: Scalars["Int"]["output"];
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly time?: Maybe<Scalars["timestamp"]["output"]>;
}

/** aggregated selection of "strapi_migrations_internal" */
export interface StrapiMigrationsInternalAggregate {
  readonly aggregate?: Maybe<StrapiMigrationsInternalAggregateFields>;
  readonly nodes: ReadonlyArray<StrapiMigrationsInternal>;
}

/** aggregate fields of "strapi_migrations_internal" */
export interface StrapiMigrationsInternalAggregateFields {
  readonly avg?: Maybe<StrapiMigrationsInternalAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<StrapiMigrationsInternalMaxFields>;
  readonly min?: Maybe<StrapiMigrationsInternalMinFields>;
  readonly stddev?: Maybe<StrapiMigrationsInternalStddevFields>;
  readonly stddev_pop?: Maybe<StrapiMigrationsInternalStddevPopFields>;
  readonly stddev_samp?: Maybe<StrapiMigrationsInternalStddevSampFields>;
  readonly sum?: Maybe<StrapiMigrationsInternalSumFields>;
  readonly var_pop?: Maybe<StrapiMigrationsInternalVarPopFields>;
  readonly var_samp?: Maybe<StrapiMigrationsInternalVarSampFields>;
  readonly variance?: Maybe<StrapiMigrationsInternalVarianceFields>;
}

/** aggregate fields of "strapi_migrations_internal" */
export type StrapiMigrationsInternalAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<StrapiMigrationsInternalSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface StrapiMigrationsInternalAvgFields {
  readonly 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 interface StrapiMigrationsInternalBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<StrapiMigrationsInternalBoolExp>>;
  readonly _not?: InputMaybe<StrapiMigrationsInternalBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<StrapiMigrationsInternalBoolExp>>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly name?: InputMaybe<StringComparisonExp>;
  readonly time?: InputMaybe<TimestampComparisonExp>;
}

/** unique or primary key constraints on table "strapi_migrations_internal" */
export type StrapiMigrationsInternalConstraint =
  /** unique or primary key constraint on columns "id" */
  "strapi_migrations_internal_pkey";

/** input type for incrementing numeric columns in table "strapi_migrations_internal" */
export interface StrapiMigrationsInternalIncInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "strapi_migrations_internal" */
export interface StrapiMigrationsInternalInsertInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly time?: InputMaybe<Scalars["timestamp"]["input"]>;
}

/** aggregate max on columns */
export interface StrapiMigrationsInternalMaxFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly time?: Maybe<Scalars["timestamp"]["output"]>;
}

/** aggregate min on columns */
export interface StrapiMigrationsInternalMinFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly time?: Maybe<Scalars["timestamp"]["output"]>;
}

/** response of any mutation on the table "strapi_migrations_internal" */
export interface StrapiMigrationsInternalMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<StrapiMigrationsInternal>;
}

/** on_conflict condition type for table "strapi_migrations_internal" */
export interface StrapiMigrationsInternalOnConflict {
  readonly constraint: StrapiMigrationsInternalConstraint;
  readonly update_columns: ReadonlyArray<StrapiMigrationsInternalUpdateColumn>;
  readonly where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
}

/** Ordering options when selecting data from "strapi_migrations_internal". */
export interface StrapiMigrationsInternalOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly name?: InputMaybe<OrderBy>;
  readonly time?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: strapi_migrations_internal */
export interface StrapiMigrationsInternalPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** select columns of table "strapi_migrations_internal" */
export type StrapiMigrationsInternalSelectColumn =
  /** column name */
  | "id"
  /** column name */
  | "name"
  /** column name */
  | "time";

/** input type for updating data in table "strapi_migrations_internal" */
export interface StrapiMigrationsInternalSetInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly time?: InputMaybe<Scalars["timestamp"]["input"]>;
}

/** aggregate stddev on columns */
export interface StrapiMigrationsInternalStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface StrapiMigrationsInternalStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface StrapiMigrationsInternalStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "strapi_migrations_internal" */
export interface StrapiMigrationsInternalStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: StrapiMigrationsInternalStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface StrapiMigrationsInternalStreamCursorValueInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly time?: InputMaybe<Scalars["timestamp"]["input"]>;
}

/** aggregate sum on columns */
export interface StrapiMigrationsInternalSumFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "strapi_migrations_internal" */
export type StrapiMigrationsInternalUpdateColumn =
  /** column name */
  | "id"
  /** column name */
  | "name"
  /** column name */
  | "time";

export interface StrapiMigrationsInternalUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<StrapiMigrationsInternalIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<StrapiMigrationsInternalSetInput>;
  /** filter the rows which have to be updated */
  readonly where: StrapiMigrationsInternalBoolExp;
}

/** aggregate var_pop on columns */
export interface StrapiMigrationsInternalVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface StrapiMigrationsInternalVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface StrapiMigrationsInternalVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate max on columns */
export interface StrapiMigrationsMaxFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly time?: Maybe<Scalars["timestamp"]["output"]>;
}

/** aggregate min on columns */
export interface StrapiMigrationsMinFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly time?: Maybe<Scalars["timestamp"]["output"]>;
}

/** response of any mutation on the table "strapi_migrations" */
export interface StrapiMigrationsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<StrapiMigrations>;
}

/** on_conflict condition type for table "strapi_migrations" */
export interface StrapiMigrationsOnConflict {
  readonly constraint: StrapiMigrationsConstraint;
  readonly update_columns: ReadonlyArray<StrapiMigrationsUpdateColumn>;
  readonly where?: InputMaybe<StrapiMigrationsBoolExp>;
}

/** Ordering options when selecting data from "strapi_migrations". */
export interface StrapiMigrationsOrderBy {
  readonly id?: InputMaybe<OrderBy>;
  readonly name?: InputMaybe<OrderBy>;
  readonly time?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: strapi_migrations */
export interface StrapiMigrationsPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** select columns of table "strapi_migrations" */
export type StrapiMigrationsSelectColumn =
  /** column name */
  | "id"
  /** column name */
  | "name"
  /** column name */
  | "time";

/** input type for updating data in table "strapi_migrations" */
export interface StrapiMigrationsSetInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly time?: InputMaybe<Scalars["timestamp"]["input"]>;
}

/** aggregate stddev on columns */
export interface StrapiMigrationsStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface StrapiMigrationsStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface StrapiMigrationsStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "strapi_migrations" */
export interface StrapiMigrationsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: StrapiMigrationsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface StrapiMigrationsStreamCursorValueInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly time?: InputMaybe<Scalars["timestamp"]["input"]>;
}

/** aggregate sum on columns */
export interface StrapiMigrationsSumFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "strapi_migrations" */
export type StrapiMigrationsUpdateColumn =
  /** column name */
  | "id"
  /** column name */
  | "name"
  /** column name */
  | "time";

export interface StrapiMigrationsUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<StrapiMigrationsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<StrapiMigrationsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: StrapiMigrationsBoolExp;
}

/** aggregate var_pop on columns */
export interface StrapiMigrationsVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface StrapiMigrationsVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface StrapiMigrationsVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

export interface SubscriptionRoot {
  /** An array relationship */
  readonly ad_daily_metrics: ReadonlyArray<AdDailyMetrics>;
  /** An aggregate relationship */
  readonly ad_daily_metrics_aggregate: AdDailyMetricsAggregate;
  /** fetch data from the table: "ad_daily_metrics" using primary key columns */
  readonly ad_daily_metrics_by_pk?: Maybe<AdDailyMetrics>;
  /** fetch data from the table in a streaming manner: "ad_daily_metrics" */
  readonly ad_daily_metrics_stream: ReadonlyArray<AdDailyMetrics>;
  /** fetch data from the table: "ad_packages" */
  readonly ad_packages: ReadonlyArray<AdPackages>;
  /** fetch aggregated fields from the table: "ad_packages" */
  readonly ad_packages_aggregate: AdPackagesAggregate;
  /** fetch data from the table: "ad_packages" using primary key columns */
  readonly ad_packages_by_pk?: Maybe<AdPackages>;
  /** fetch data from the table in a streaming manner: "ad_packages" */
  readonly ad_packages_stream: ReadonlyArray<AdPackages>;
  /** An array relationship */
  readonly ad_variants: ReadonlyArray<AdVariants>;
  /** An aggregate relationship */
  readonly ad_variants_aggregate: AdVariantsAggregate;
  /** fetch data from the table: "ad_variants" using primary key columns */
  readonly ad_variants_by_pk?: Maybe<AdVariants>;
  /** fetch data from the table in a streaming manner: "ad_variants" */
  readonly ad_variants_stream: ReadonlyArray<AdVariants>;
  /** An array relationship */
  readonly addresses: ReadonlyArray<Addresses>;
  /** An aggregate relationship */
  readonly addresses_aggregate: AddressesAggregate;
  /** fetch data from the table: "addresses" using primary key columns */
  readonly addresses_by_pk?: Maybe<Addresses>;
  /** fetch data from the table in a streaming manner: "addresses" */
  readonly addresses_stream: ReadonlyArray<Addresses>;
  /** An array relationship */
  readonly ads: ReadonlyArray<Ads>;
  /** An aggregate relationship */
  readonly ads_aggregate: AdsAggregate;
  /** fetch data from the table: "ads" using primary key columns */
  readonly ads_by_pk?: Maybe<Ads>;
  /** fetch data from the table in a streaming manner: "ads" */
  readonly ads_stream: ReadonlyArray<Ads>;
  /** fetch data from the table: "blacklisted_domains" */
  readonly blacklisted_domains: ReadonlyArray<BlacklistedDomains>;
  /** fetch aggregated fields from the table: "blacklisted_domains" */
  readonly blacklisted_domains_aggregate: BlacklistedDomainsAggregate;
  /** fetch data from the table: "blacklisted_domains" using primary key columns */
  readonly blacklisted_domains_by_pk?: Maybe<BlacklistedDomains>;
  /** fetch data from the table in a streaming manner: "blacklisted_domains" */
  readonly blacklisted_domains_stream: ReadonlyArray<BlacklistedDomains>;
  /** An array relationship */
  readonly blacklisted_urls: ReadonlyArray<BlacklistedUrls>;
  /** An aggregate relationship */
  readonly blacklisted_urls_aggregate: BlacklistedUrlsAggregate;
  /** fetch data from the table: "blacklisted_urls" using primary key columns */
  readonly blacklisted_urls_by_pk?: Maybe<BlacklistedUrls>;
  /** fetch data from the table in a streaming manner: "blacklisted_urls" */
  readonly blacklisted_urls_stream: ReadonlyArray<BlacklistedUrls>;
  /** fetch data from the table: "blocked_ips" */
  readonly blocked_ips: ReadonlyArray<BlockedIps>;
  /** fetch aggregated fields from the table: "blocked_ips" */
  readonly blocked_ips_aggregate: BlockedIpsAggregate;
  /** fetch data from the table: "blocked_ips" using primary key columns */
  readonly blocked_ips_by_pk?: Maybe<BlockedIps>;
  /** fetch data from the table in a streaming manner: "blocked_ips" */
  readonly blocked_ips_stream: ReadonlyArray<BlockedIps>;
  /** An array relationship */
  readonly bookmark_folders: ReadonlyArray<BookmarkFolders>;
  /** An aggregate relationship */
  readonly bookmark_folders_aggregate: BookmarkFoldersAggregate;
  /** fetch data from the table: "bookmark_folders" using primary key columns */
  readonly bookmark_folders_by_pk?: Maybe<BookmarkFolders>;
  /** fetch data from the table in a streaming manner: "bookmark_folders" */
  readonly bookmark_folders_stream: ReadonlyArray<BookmarkFolders>;
  /** An array relationship */
  readonly bookmarks: ReadonlyArray<Bookmarks>;
  /** An aggregate relationship */
  readonly bookmarks_aggregate: BookmarksAggregate;
  /** fetch data from the table: "bookmarks" using primary key columns */
  readonly bookmarks_by_pk?: Maybe<Bookmarks>;
  /** fetch data from the table in a streaming manner: "bookmarks" */
  readonly bookmarks_stream: ReadonlyArray<Bookmarks>;
  /** An array relationship */
  readonly business_domains: ReadonlyArray<BusinessDomains>;
  /** An aggregate relationship */
  readonly business_domains_aggregate: BusinessDomainsAggregate;
  /** fetch data from the table: "business_domains" using primary key columns */
  readonly business_domains_by_pk?: Maybe<BusinessDomains>;
  /** fetch data from the table in a streaming manner: "business_domains" */
  readonly business_domains_stream: ReadonlyArray<BusinessDomains>;
  /** fetch data from the table: "categories" */
  readonly categories: ReadonlyArray<Categories>;
  /** fetch aggregated fields from the table: "categories" */
  readonly categories_aggregate: CategoriesAggregate;
  /** fetch data from the table: "categories" using primary key columns */
  readonly categories_by_pk?: Maybe<Categories>;
  /** fetch data from the table in a streaming manner: "categories" */
  readonly categories_stream: ReadonlyArray<Categories>;
  /** An array relationship */
  readonly categorized_urls: ReadonlyArray<CategorizedUrls>;
  /** An aggregate relationship */
  readonly categorized_urls_aggregate: CategorizedUrlsAggregate;
  /** fetch data from the table: "categorized_urls" using primary key columns */
  readonly categorized_urls_by_pk?: Maybe<CategorizedUrls>;
  /** fetch data from the table in a streaming manner: "categorized_urls" */
  readonly categorized_urls_stream: ReadonlyArray<CategorizedUrls>;
  /** fetch data from the table: "circuit_breaker_states" */
  readonly circuit_breaker_states: ReadonlyArray<CircuitBreakerStates>;
  /** fetch aggregated fields from the table: "circuit_breaker_states" */
  readonly circuit_breaker_states_aggregate: CircuitBreakerStatesAggregate;
  /** fetch data from the table: "circuit_breaker_states" using primary key columns */
  readonly circuit_breaker_states_by_pk?: Maybe<CircuitBreakerStates>;
  /** fetch data from the table in a streaming manner: "circuit_breaker_states" */
  readonly circuit_breaker_states_stream: ReadonlyArray<CircuitBreakerStates>;
  /** An array relationship */
  readonly cities: ReadonlyArray<Cities>;
  /** An aggregate relationship */
  readonly cities_aggregate: CitiesAggregate;
  /** fetch data from the table: "cities" using primary key columns */
  readonly cities_by_pk?: Maybe<Cities>;
  /** fetch data from the table in a streaming manner: "cities" */
  readonly cities_stream: ReadonlyArray<Cities>;
  /** An array relationship */
  readonly comments: ReadonlyArray<Comments>;
  /** An aggregate relationship */
  readonly comments_aggregate: CommentsAggregate;
  /** fetch data from the table: "comments" using primary key columns */
  readonly comments_by_pk?: Maybe<Comments>;
  /** fetch data from the table in a streaming manner: "comments" */
  readonly comments_stream: ReadonlyArray<Comments>;
  /** An array relationship */
  readonly companies: ReadonlyArray<Companies>;
  /** An aggregate relationship */
  readonly companies_aggregate: CompaniesAggregate;
  /** fetch data from the table: "companies" using primary key columns */
  readonly companies_by_pk?: Maybe<Companies>;
  /** fetch data from the table in a streaming manner: "companies" */
  readonly companies_stream: ReadonlyArray<Companies>;
  /** An array relationship */
  readonly company_contacts: ReadonlyArray<CompanyContacts>;
  /** An aggregate relationship */
  readonly company_contacts_aggregate: CompanyContactsAggregate;
  /** fetch data from the table: "company_contacts" using primary key columns */
  readonly company_contacts_by_pk?: Maybe<CompanyContacts>;
  /** fetch data from the table in a streaming manner: "company_contacts" */
  readonly company_contacts_stream: ReadonlyArray<CompanyContacts>;
  /** An array relationship */
  readonly company_employees: ReadonlyArray<CompanyEmployees>;
  /** An aggregate relationship */
  readonly company_employees_aggregate: CompanyEmployeesAggregate;
  /** fetch data from the table: "company_employees" using primary key columns */
  readonly company_employees_by_pk?: Maybe<CompanyEmployees>;
  /** fetch data from the table in a streaming manner: "company_employees" */
  readonly company_employees_stream: ReadonlyArray<CompanyEmployees>;
  /** An array relationship */
  readonly company_extras: ReadonlyArray<CompanyExtras>;
  /** An aggregate relationship */
  readonly company_extras_aggregate: CompanyExtrasAggregate;
  /** fetch data from the table: "company_extras" using primary key columns */
  readonly company_extras_by_pk?: Maybe<CompanyExtras>;
  /** fetch data from the table in a streaming manner: "company_extras" */
  readonly company_extras_stream: ReadonlyArray<CompanyExtras>;
  /** An array relationship */
  readonly company_metrics: ReadonlyArray<CompanyMetrics>;
  /** An aggregate relationship */
  readonly company_metrics_aggregate: CompanyMetricsAggregate;
  /** fetch data from the table: "company_metrics" using primary key columns */
  readonly company_metrics_by_pk?: Maybe<CompanyMetrics>;
  /** fetch data from the table in a streaming manner: "company_metrics" */
  readonly company_metrics_stream: ReadonlyArray<CompanyMetrics>;
  /** An array relationship */
  readonly contacts: ReadonlyArray<Contacts>;
  /** An aggregate relationship */
  readonly contacts_aggregate: ContactsAggregate;
  /** fetch data from the table: "contacts" using primary key columns */
  readonly contacts_by_pk?: Maybe<Contacts>;
  /** fetch data from the table in a streaming manner: "contacts" */
  readonly contacts_stream: ReadonlyArray<Contacts>;
  /** An array relationship */
  readonly content_categories: ReadonlyArray<ContentCategories>;
  /** An aggregate relationship */
  readonly content_categories_aggregate: ContentCategoriesAggregate;
  /** fetch data from the table: "content_categories" using primary key columns */
  readonly content_categories_by_pk?: Maybe<ContentCategories>;
  /** fetch data from the table in a streaming manner: "content_categories" */
  readonly content_categories_stream: ReadonlyArray<ContentCategories>;
  /** fetch data from the table: "content_scores" */
  readonly content_scores: ReadonlyArray<ContentScores>;
  /** fetch aggregated fields from the table: "content_scores" */
  readonly content_scores_aggregate: ContentScoresAggregate;
  /** fetch data from the table in a streaming manner: "content_scores" */
  readonly content_scores_stream: ReadonlyArray<ContentScores>;
  /** An array relationship */
  readonly content_source_visits: ReadonlyArray<ContentSourceVisits>;
  /** An aggregate relationship */
  readonly content_source_visits_aggregate: ContentSourceVisitsAggregate;
  /** fetch data from the table: "content_source_visits" using primary key columns */
  readonly content_source_visits_by_pk?: Maybe<ContentSourceVisits>;
  /** fetch data from the table in a streaming manner: "content_source_visits" */
  readonly content_source_visits_stream: ReadonlyArray<ContentSourceVisits>;
  /** An array relationship */
  readonly content_sources: ReadonlyArray<ContentSources>;
  /** An aggregate relationship */
  readonly content_sources_aggregate: ContentSourcesAggregate;
  /** fetch data from the table: "content_sources" using primary key columns */
  readonly content_sources_by_pk?: Maybe<ContentSources>;
  /** fetch data from the table in a streaming manner: "content_sources" */
  readonly content_sources_stream: ReadonlyArray<ContentSources>;
  /** An array relationship */
  readonly content_statuses: ReadonlyArray<ContentStatuses>;
  /** An aggregate relationship */
  readonly content_statuses_aggregate: ContentStatusesAggregate;
  /** fetch data from the table: "content_statuses" using primary key columns */
  readonly content_statuses_by_pk?: Maybe<ContentStatuses>;
  /** fetch data from the table in a streaming manner: "content_statuses" */
  readonly content_statuses_stream: ReadonlyArray<ContentStatuses>;
  /** An array relationship */
  readonly content_tags: ReadonlyArray<ContentTags>;
  /** An aggregate relationship */
  readonly content_tags_aggregate: ContentTagsAggregate;
  /** fetch data from the table: "content_tags" using primary key columns */
  readonly content_tags_by_pk?: Maybe<ContentTags>;
  /** fetch data from the table in a streaming manner: "content_tags" */
  readonly content_tags_stream: ReadonlyArray<ContentTags>;
  /** fetch data from the table: "contents" */
  readonly contents: ReadonlyArray<Contents>;
  /** fetch aggregated fields from the table: "contents" */
  readonly contents_aggregate: ContentsAggregate;
  /** fetch data from the table: "contents" using primary key columns */
  readonly contents_by_pk?: Maybe<Contents>;
  /** fetch data from the table in a streaming manner: "contents" */
  readonly contents_stream: ReadonlyArray<Contents>;
  /** fetch data from the table: "countries" */
  readonly countries: ReadonlyArray<Countries>;
  /** fetch aggregated fields from the table: "countries" */
  readonly countries_aggregate: CountriesAggregate;
  /** fetch data from the table: "countries" using primary key columns */
  readonly countries_by_pk?: Maybe<Countries>;
  /** fetch data from the table in a streaming manner: "countries" */
  readonly countries_stream: ReadonlyArray<Countries>;
  /** An array relationship */
  readonly customer_payments: ReadonlyArray<CustomerPayments>;
  /** An aggregate relationship */
  readonly customer_payments_aggregate: CustomerPaymentsAggregate;
  /** fetch data from the table: "customer_payments" using primary key columns */
  readonly customer_payments_by_pk?: Maybe<CustomerPayments>;
  /** fetch data from the table in a streaming manner: "customer_payments" */
  readonly customer_payments_stream: ReadonlyArray<CustomerPayments>;
  /** fetch data from the table: "customer_processed_webhooks" */
  readonly customer_processed_webhooks: ReadonlyArray<CustomerProcessedWebhooks>;
  /** fetch aggregated fields from the table: "customer_processed_webhooks" */
  readonly customer_processed_webhooks_aggregate: CustomerProcessedWebhooksAggregate;
  /** fetch data from the table: "customer_processed_webhooks" using primary key columns */
  readonly customer_processed_webhooks_by_pk?: Maybe<CustomerProcessedWebhooks>;
  /** fetch data from the table in a streaming manner: "customer_processed_webhooks" */
  readonly customer_processed_webhooks_stream: ReadonlyArray<CustomerProcessedWebhooks>;
  /** An array relationship */
  readonly customer_refunds: ReadonlyArray<CustomerRefunds>;
  /** An aggregate relationship */
  readonly customer_refunds_aggregate: CustomerRefundsAggregate;
  /** fetch data from the table: "customer_refunds" using primary key columns */
  readonly customer_refunds_by_pk?: Maybe<CustomerRefunds>;
  /** fetch data from the table in a streaming manner: "customer_refunds" */
  readonly customer_refunds_stream: ReadonlyArray<CustomerRefunds>;
  /** fetch data from the table: "customer_subscription_plans" */
  readonly customer_subscription_plans: ReadonlyArray<CustomerSubscriptionPlans>;
  /** fetch aggregated fields from the table: "customer_subscription_plans" */
  readonly customer_subscription_plans_aggregate: CustomerSubscriptionPlansAggregate;
  /** fetch data from the table: "customer_subscription_plans" using primary key columns */
  readonly customer_subscription_plans_by_pk?: Maybe<CustomerSubscriptionPlans>;
  /** fetch data from the table in a streaming manner: "customer_subscription_plans" */
  readonly customer_subscription_plans_stream: ReadonlyArray<CustomerSubscriptionPlans>;
  /** An array relationship */
  readonly customer_subscriptions: ReadonlyArray<CustomerSubscriptions>;
  /** An aggregate relationship */
  readonly customer_subscriptions_aggregate: CustomerSubscriptionsAggregate;
  /** fetch data from the table: "customer_subscriptions" using primary key columns */
  readonly customer_subscriptions_by_pk?: Maybe<CustomerSubscriptions>;
  /** fetch data from the table in a streaming manner: "customer_subscriptions" */
  readonly customer_subscriptions_stream: ReadonlyArray<CustomerSubscriptions>;
  /** fetch data from the table: "embedding_reviews" */
  readonly embedding_reviews: ReadonlyArray<EmbeddingReviews>;
  /** fetch aggregated fields from the table: "embedding_reviews" */
  readonly embedding_reviews_aggregate: EmbeddingReviewsAggregate;
  /** fetch data from the table: "embedding_reviews" using primary key columns */
  readonly embedding_reviews_by_pk?: Maybe<EmbeddingReviews>;
  /** fetch data from the table in a streaming manner: "embedding_reviews" */
  readonly embedding_reviews_stream: ReadonlyArray<EmbeddingReviews>;
  /** fetch data from the table: "error_correlations" */
  readonly error_correlations: ReadonlyArray<ErrorCorrelations>;
  /** fetch aggregated fields from the table: "error_correlations" */
  readonly error_correlations_aggregate: ErrorCorrelationsAggregate;
  /** fetch data from the table in a streaming manner: "error_correlations" */
  readonly error_correlations_stream: ReadonlyArray<ErrorCorrelations>;
  /** fetch data from the table: "error_frequency" */
  readonly error_frequency: ReadonlyArray<ErrorFrequency>;
  /** fetch aggregated fields from the table: "error_frequency" */
  readonly error_frequency_aggregate: ErrorFrequencyAggregate;
  /** fetch data from the table in a streaming manner: "error_frequency" */
  readonly error_frequency_stream: ReadonlyArray<ErrorFrequency>;
  /** fetch data from the table: "error_logs" */
  readonly error_logs: ReadonlyArray<ErrorLogs>;
  /** fetch aggregated fields from the table: "error_logs" */
  readonly error_logs_aggregate: ErrorLogsAggregate;
  /** fetch data from the table: "error_logs" using primary key columns */
  readonly error_logs_by_pk?: Maybe<ErrorLogs>;
  /** fetch data from the table in a streaming manner: "error_logs" */
  readonly error_logs_stream: ReadonlyArray<ErrorLogs>;
  /** fetch data from the table: "error_metrics" */
  readonly error_metrics: ReadonlyArray<ErrorMetrics>;
  /** fetch aggregated fields from the table: "error_metrics" */
  readonly error_metrics_aggregate: ErrorMetricsAggregate;
  /** fetch data from the table in a streaming manner: "error_metrics" */
  readonly error_metrics_stream: ReadonlyArray<ErrorMetrics>;
  /** fetch data from the table: "error_patterns" */
  readonly error_patterns: ReadonlyArray<ErrorPatterns>;
  /** fetch aggregated fields from the table: "error_patterns" */
  readonly error_patterns_aggregate: ErrorPatternsAggregate;
  /** fetch data from the table in a streaming manner: "error_patterns" */
  readonly error_patterns_stream: ReadonlyArray<ErrorPatterns>;
  /** fetch data from the table: "error_stats" */
  readonly error_stats: ReadonlyArray<ErrorStats>;
  /** fetch aggregated fields from the table: "error_stats" */
  readonly error_stats_aggregate: ErrorStatsAggregate;
  /** fetch data from the table in a streaming manner: "error_stats" */
  readonly error_stats_stream: ReadonlyArray<ErrorStats>;
  /** fetch data from the table: "feature_requests" */
  readonly feature_requests: ReadonlyArray<FeatureRequests>;
  /** fetch aggregated fields from the table: "feature_requests" */
  readonly feature_requests_aggregate: FeatureRequestsAggregate;
  /** fetch data from the table: "feature_requests" using primary key columns */
  readonly feature_requests_by_pk?: Maybe<FeatureRequests>;
  /** fetch data from the table in a streaming manner: "feature_requests" */
  readonly feature_requests_stream: ReadonlyArray<FeatureRequests>;
  /** An array relationship */
  readonly feature_votes: ReadonlyArray<FeatureVotes>;
  /** An aggregate relationship */
  readonly feature_votes_aggregate: FeatureVotesAggregate;
  /** fetch data from the table: "feature_votes" using primary key columns */
  readonly feature_votes_by_pk?: Maybe<FeatureVotes>;
  /** fetch data from the table in a streaming manner: "feature_votes" */
  readonly feature_votes_stream: ReadonlyArray<FeatureVotes>;
  /** An array relationship */
  readonly feed_categories: ReadonlyArray<FeedCategories>;
  /** An aggregate relationship */
  readonly feed_categories_aggregate: FeedCategoriesAggregate;
  /** fetch data from the table: "feed_categories" using primary key columns */
  readonly feed_categories_by_pk?: Maybe<FeedCategories>;
  /** fetch data from the table in a streaming manner: "feed_categories" */
  readonly feed_categories_stream: ReadonlyArray<FeedCategories>;
  /** An array relationship */
  readonly feed_sources: ReadonlyArray<FeedSources>;
  /** An aggregate relationship */
  readonly feed_sources_aggregate: FeedSourcesAggregate;
  /** fetch data from the table: "feed_sources" using primary key columns */
  readonly feed_sources_by_pk?: Maybe<FeedSources>;
  /** fetch data from the table in a streaming manner: "feed_sources" */
  readonly feed_sources_stream: ReadonlyArray<FeedSources>;
  /** An array relationship */
  readonly feedbacks: ReadonlyArray<Feedbacks>;
  /** An aggregate relationship */
  readonly feedbacks_aggregate: FeedbacksAggregate;
  /** fetch data from the table: "feedbacks" using primary key columns */
  readonly feedbacks_by_pk?: Maybe<Feedbacks>;
  /** fetch data from the table in a streaming manner: "feedbacks" */
  readonly feedbacks_stream: ReadonlyArray<Feedbacks>;
  /** An array relationship */
  readonly feeds: ReadonlyArray<Feeds>;
  /** An aggregate relationship */
  readonly feeds_aggregate: FeedsAggregate;
  /** fetch data from the table: "feeds" using primary key columns */
  readonly feeds_by_pk?: Maybe<Feeds>;
  /** fetch data from the table in a streaming manner: "feeds" */
  readonly feeds_stream: ReadonlyArray<Feeds>;
  /** An array relationship */
  readonly follows: ReadonlyArray<Follows>;
  /** An aggregate relationship */
  readonly follows_aggregate: FollowsAggregate;
  /** fetch data from the table: "follows" using primary key columns */
  readonly follows_by_pk?: Maybe<Follows>;
  /** fetch data from the table in a streaming manner: "follows" */
  readonly follows_stream: ReadonlyArray<Follows>;
  /** fetch data from the table: "metric_definitions" */
  readonly metric_definitions: ReadonlyArray<MetricDefinitions>;
  /** fetch aggregated fields from the table: "metric_definitions" */
  readonly metric_definitions_aggregate: MetricDefinitionsAggregate;
  /** fetch data from the table: "metric_definitions" using primary key columns */
  readonly metric_definitions_by_pk?: Maybe<MetricDefinitions>;
  /** fetch data from the table in a streaming manner: "metric_definitions" */
  readonly metric_definitions_stream: ReadonlyArray<MetricDefinitions>;
  /** An array relationship */
  readonly news: ReadonlyArray<News>;
  /** An aggregate relationship */
  readonly news_aggregate: NewsAggregate;
  /** fetch data from the table: "news" using primary key columns */
  readonly news_by_pk?: Maybe<News>;
  /** fetch data from the table: "news_details" */
  readonly news_details: ReadonlyArray<NewsDetails>;
  /** fetch aggregated fields from the table: "news_details" */
  readonly news_details_aggregate: NewsDetailsAggregate;
  /** fetch data from the table in a streaming manner: "news_details" */
  readonly news_details_stream: ReadonlyArray<NewsDetails>;
  /** fetch data from the table in a streaming manner: "news" */
  readonly news_stream: ReadonlyArray<News>;
  /** An array relationship */
  readonly news_summaries: ReadonlyArray<NewsSummaries>;
  /** An aggregate relationship */
  readonly news_summaries_aggregate: NewsSummariesAggregate;
  /** fetch data from the table: "news_summaries" using primary key columns */
  readonly news_summaries_by_pk?: Maybe<NewsSummaries>;
  /** fetch data from the table in a streaming manner: "news_summaries" */
  readonly news_summaries_stream: ReadonlyArray<NewsSummaries>;
  /** An array relationship */
  readonly news_tags: ReadonlyArray<NewsTags>;
  /** An aggregate relationship */
  readonly news_tags_aggregate: NewsTagsAggregate;
  /** fetch data from the table: "news_tags" using primary key columns */
  readonly news_tags_by_pk?: Maybe<NewsTags>;
  /** fetch data from the table in a streaming manner: "news_tags" */
  readonly news_tags_stream: ReadonlyArray<NewsTags>;
  /** fetch data from the table: "newsletters" */
  readonly newsletters: ReadonlyArray<Newsletters>;
  /** fetch aggregated fields from the table: "newsletters" */
  readonly newsletters_aggregate: NewslettersAggregate;
  /** fetch data from the table: "newsletters" using primary key columns */
  readonly newsletters_by_pk?: Maybe<Newsletters>;
  /** fetch data from the table in a streaming manner: "newsletters" */
  readonly newsletters_stream: ReadonlyArray<Newsletters>;
  /** fetch data from the table: "payment_providers" */
  readonly payment_providers: ReadonlyArray<PaymentProviders>;
  /** fetch aggregated fields from the table: "payment_providers" */
  readonly payment_providers_aggregate: PaymentProvidersAggregate;
  /** fetch data from the table: "payment_providers" using primary key columns */
  readonly payment_providers_by_pk?: Maybe<PaymentProviders>;
  /** fetch data from the table in a streaming manner: "payment_providers" */
  readonly payment_providers_stream: ReadonlyArray<PaymentProviders>;
  /** fetch data from the table: "plan_permissions" */
  readonly plan_permissions: ReadonlyArray<PlanPermissions>;
  /** fetch aggregated fields from the table: "plan_permissions" */
  readonly plan_permissions_aggregate: PlanPermissionsAggregate;
  /** fetch data from the table: "plan_permissions" using primary key columns */
  readonly plan_permissions_by_pk?: Maybe<PlanPermissions>;
  /** fetch data from the table in a streaming manner: "plan_permissions" */
  readonly plan_permissions_stream: ReadonlyArray<PlanPermissions>;
  /** fetch data from the table: "recent_errors" */
  readonly recent_errors: ReadonlyArray<RecentErrors>;
  /** fetch aggregated fields from the table: "recent_errors" */
  readonly recent_errors_aggregate: RecentErrorsAggregate;
  /** fetch data from the table in a streaming manner: "recent_errors" */
  readonly recent_errors_stream: ReadonlyArray<RecentErrors>;
  /** fetch data from the table: "referral_stats" */
  readonly referral_stats: ReadonlyArray<ReferralStats>;
  /** fetch aggregated fields from the table: "referral_stats" */
  readonly referral_stats_aggregate: ReferralStatsAggregate;
  /** fetch data from the table in a streaming manner: "referral_stats" */
  readonly referral_stats_stream: ReadonlyArray<ReferralStats>;
  /** fetch data from the table: "referrals" */
  readonly referrals: ReadonlyArray<Referrals>;
  /** fetch aggregated fields from the table: "referrals" */
  readonly referrals_aggregate: ReferralsAggregate;
  /** fetch data from the table: "referrals" using primary key columns */
  readonly referrals_by_pk?: Maybe<Referrals>;
  /** fetch data from the table in a streaming manner: "referrals" */
  readonly referrals_stream: ReadonlyArray<Referrals>;
  /** fetch data from the table: "referrer_blocks" */
  readonly referrer_blocks: ReadonlyArray<ReferrerBlocks>;
  /** fetch aggregated fields from the table: "referrer_blocks" */
  readonly referrer_blocks_aggregate: ReferrerBlocksAggregate;
  /** fetch data from the table: "referrer_blocks" using primary key columns */
  readonly referrer_blocks_by_pk?: Maybe<ReferrerBlocks>;
  /** fetch data from the table in a streaming manner: "referrer_blocks" */
  readonly referrer_blocks_stream: ReadonlyArray<ReferrerBlocks>;
  /** fetch data from the table: "referrer_risk_metrics" */
  readonly referrer_risk_metrics: ReadonlyArray<ReferrerRiskMetrics>;
  /** fetch aggregated fields from the table: "referrer_risk_metrics" */
  readonly referrer_risk_metrics_aggregate: ReferrerRiskMetricsAggregate;
  /** fetch data from the table in a streaming manner: "referrer_risk_metrics" */
  readonly referrer_risk_metrics_stream: ReadonlyArray<ReferrerRiskMetrics>;
  /** fetch data from the table: "research" */
  readonly research: ReadonlyArray<Research>;
  /** fetch aggregated fields from the table: "research" */
  readonly research_aggregate: ResearchAggregate;
  /** fetch data from the table: "research" using primary key columns */
  readonly research_by_pk?: Maybe<Research>;
  /** An array relationship */
  readonly research_embeddings: ReadonlyArray<ResearchEmbeddings>;
  /** An aggregate relationship */
  readonly research_embeddings_aggregate: ResearchEmbeddingsAggregate;
  /** fetch data from the table: "research_embeddings" using primary key columns */
  readonly research_embeddings_by_pk?: Maybe<ResearchEmbeddings>;
  /** fetch data from the table in a streaming manner: "research_embeddings" */
  readonly research_embeddings_stream: ReadonlyArray<ResearchEmbeddings>;
  /** fetch data from the table in a streaming manner: "research" */
  readonly research_stream: ReadonlyArray<Research>;
  /** An array relationship */
  readonly responses: ReadonlyArray<Responses>;
  /** An aggregate relationship */
  readonly responses_aggregate: ResponsesAggregate;
  /** fetch data from the table: "responses" using primary key columns */
  readonly responses_by_pk?: Maybe<Responses>;
  /** fetch data from the table in a streaming manner: "responses" */
  readonly responses_stream: ReadonlyArray<Responses>;
  /** fetch data from the table: "role_hierarchy" */
  readonly role_hierarchy: ReadonlyArray<RoleHierarchy>;
  /** fetch aggregated fields from the table: "role_hierarchy" */
  readonly role_hierarchy_aggregate: RoleHierarchyAggregate;
  /** fetch data from the table: "role_hierarchy" using primary key columns */
  readonly role_hierarchy_by_pk?: Maybe<RoleHierarchy>;
  /** fetch data from the table in a streaming manner: "role_hierarchy" */
  readonly role_hierarchy_stream: ReadonlyArray<RoleHierarchy>;
  /** fetch data from the table: "role_permissions" */
  readonly role_permissions: ReadonlyArray<RolePermissions>;
  /** fetch aggregated fields from the table: "role_permissions" */
  readonly role_permissions_aggregate: RolePermissionsAggregate;
  /** fetch data from the table: "role_permissions" using primary key columns */
  readonly role_permissions_by_pk?: Maybe<RolePermissions>;
  /** fetch data from the table: "role_permissions_materialized" */
  readonly role_permissions_materialized: ReadonlyArray<RolePermissionsMaterialized>;
  /** fetch aggregated fields from the table: "role_permissions_materialized" */
  readonly role_permissions_materialized_aggregate: RolePermissionsMaterializedAggregate;
  /** fetch data from the table: "role_permissions_materialized" using primary key columns */
  readonly role_permissions_materialized_by_pk?: Maybe<RolePermissionsMaterialized>;
  /** fetch data from the table in a streaming manner: "role_permissions_materialized" */
  readonly role_permissions_materialized_stream: ReadonlyArray<RolePermissionsMaterialized>;
  /** fetch data from the table in a streaming manner: "role_permissions" */
  readonly role_permissions_stream: ReadonlyArray<RolePermissions>;
  /** fetch data from the table: "scoring_weights" */
  readonly scoring_weights: ReadonlyArray<ScoringWeights>;
  /** fetch aggregated fields from the table: "scoring_weights" */
  readonly scoring_weights_aggregate: ScoringWeightsAggregate;
  /** fetch data from the table: "scoring_weights" using primary key columns */
  readonly scoring_weights_by_pk?: Maybe<ScoringWeights>;
  /** fetch data from the table in a streaming manner: "scoring_weights" */
  readonly scoring_weights_stream: ReadonlyArray<ScoringWeights>;
  /** fetch data from the table: "searches" */
  readonly searches: ReadonlyArray<Searches>;
  /** fetch aggregated fields from the table: "searches" */
  readonly searches_aggregate: SearchesAggregate;
  /** fetch data from the table: "searches" using primary key columns */
  readonly searches_by_pk?: Maybe<Searches>;
  /** fetch data from the table in a streaming manner: "searches" */
  readonly searches_stream: ReadonlyArray<Searches>;
  /** fetch data from the table: "security_metrics" */
  readonly security_metrics: ReadonlyArray<SecurityMetrics>;
  /** fetch aggregated fields from the table: "security_metrics" */
  readonly security_metrics_aggregate: SecurityMetricsAggregate;
  /** fetch data from the table in a streaming manner: "security_metrics" */
  readonly security_metrics_stream: ReadonlyArray<SecurityMetrics>;
  /** fetch data from the table: "slow_query_patterns" */
  readonly slow_query_patterns: ReadonlyArray<SlowQueryPatterns>;
  /** fetch aggregated fields from the table: "slow_query_patterns" */
  readonly slow_query_patterns_aggregate: SlowQueryPatternsAggregate;
  /** fetch data from the table in a streaming manner: "slow_query_patterns" */
  readonly slow_query_patterns_stream: ReadonlyArray<SlowQueryPatterns>;
  /** fetch data from the table: "social_media" */
  readonly social_media: ReadonlyArray<SocialMedia>;
  /** fetch aggregated fields from the table: "social_media" */
  readonly social_media_aggregate: SocialMediaAggregate;
  /** fetch data from the table: "social_media" using primary key columns */
  readonly social_media_by_pk?: Maybe<SocialMedia>;
  /** fetch data from the table in a streaming manner: "social_media" */
  readonly social_media_stream: ReadonlyArray<SocialMedia>;
  /** An array relationship */
  readonly spider_metrics: ReadonlyArray<SpiderMetrics>;
  /** An aggregate relationship */
  readonly spider_metrics_aggregate: SpiderMetricsAggregate;
  /** fetch data from the table: "spider_metrics" using primary key columns */
  readonly spider_metrics_by_pk?: Maybe<SpiderMetrics>;
  /** fetch data from the table in a streaming manner: "spider_metrics" */
  readonly spider_metrics_stream: ReadonlyArray<SpiderMetrics>;
  /** fetch data from the table: "strapi_migrations" */
  readonly strapi_migrations: ReadonlyArray<StrapiMigrations>;
  /** fetch aggregated fields from the table: "strapi_migrations" */
  readonly strapi_migrations_aggregate: StrapiMigrationsAggregate;
  /** fetch data from the table: "strapi_migrations" using primary key columns */
  readonly strapi_migrations_by_pk?: Maybe<StrapiMigrations>;
  /** fetch data from the table: "strapi_migrations_internal" */
  readonly strapi_migrations_internal: ReadonlyArray<StrapiMigrationsInternal>;
  /** fetch aggregated fields from the table: "strapi_migrations_internal" */
  readonly strapi_migrations_internal_aggregate: StrapiMigrationsInternalAggregate;
  /** fetch data from the table: "strapi_migrations_internal" using primary key columns */
  readonly strapi_migrations_internal_by_pk?: Maybe<StrapiMigrationsInternal>;
  /** fetch data from the table in a streaming manner: "strapi_migrations_internal" */
  readonly strapi_migrations_internal_stream: ReadonlyArray<StrapiMigrationsInternal>;
  /** fetch data from the table in a streaming manner: "strapi_migrations" */
  readonly strapi_migrations_stream: ReadonlyArray<StrapiMigrations>;
  /** fetch data from the table: "table_maintenance_log" */
  readonly table_maintenance_log: ReadonlyArray<TableMaintenanceLog>;
  /** fetch aggregated fields from the table: "table_maintenance_log" */
  readonly table_maintenance_log_aggregate: TableMaintenanceLogAggregate;
  /** fetch data from the table: "table_maintenance_log" using primary key columns */
  readonly table_maintenance_log_by_pk?: Maybe<TableMaintenanceLog>;
  /** fetch data from the table in a streaming manner: "table_maintenance_log" */
  readonly table_maintenance_log_stream: ReadonlyArray<TableMaintenanceLog>;
  /** fetch data from the table: "table_query_performance" */
  readonly table_query_performance: ReadonlyArray<TableQueryPerformance>;
  /** fetch aggregated fields from the table: "table_query_performance" */
  readonly table_query_performance_aggregate: TableQueryPerformanceAggregate;
  /** fetch data from the table in a streaming manner: "table_query_performance" */
  readonly table_query_performance_stream: ReadonlyArray<TableQueryPerformance>;
  /** fetch data from the table: "table_sequence_usage" */
  readonly table_sequence_usage: ReadonlyArray<TableSequenceUsage>;
  /** fetch aggregated fields from the table: "table_sequence_usage" */
  readonly table_sequence_usage_aggregate: TableSequenceUsageAggregate;
  /** fetch data from the table in a streaming manner: "table_sequence_usage" */
  readonly table_sequence_usage_stream: ReadonlyArray<TableSequenceUsage>;
  /** fetch data from the table: "table_statistics" */
  readonly table_statistics: ReadonlyArray<TableStatistics>;
  /** fetch aggregated fields from the table: "table_statistics" */
  readonly table_statistics_aggregate: TableStatisticsAggregate;
  /** fetch data from the table: "table_statistics" using primary key columns */
  readonly table_statistics_by_pk?: Maybe<TableStatistics>;
  /** fetch data from the table in a streaming manner: "table_statistics" */
  readonly table_statistics_stream: ReadonlyArray<TableStatistics>;
  /** fetch data from the table: "tags" */
  readonly tags: ReadonlyArray<Tags>;
  /** fetch aggregated fields from the table: "tags" */
  readonly tags_aggregate: TagsAggregate;
  /** fetch data from the table: "tags" using primary key columns */
  readonly tags_by_pk?: Maybe<Tags>;
  /** fetch data from the table in a streaming manner: "tags" */
  readonly tags_stream: ReadonlyArray<Tags>;
  /** fetch data from the table: "user_metrics" */
  readonly user_metrics: ReadonlyArray<UserMetrics>;
  /** fetch aggregated fields from the table: "user_metrics" */
  readonly user_metrics_aggregate: UserMetricsAggregate;
  /** fetch data from the table: "user_metrics" using primary key columns */
  readonly user_metrics_by_pk?: Maybe<UserMetrics>;
  /** fetch data from the table in a streaming manner: "user_metrics" */
  readonly user_metrics_stream: ReadonlyArray<UserMetrics>;
  /** fetch data from the table: "user_profiles" */
  readonly user_profiles: ReadonlyArray<UserProfiles>;
  /** fetch aggregated fields from the table: "user_profiles" */
  readonly user_profiles_aggregate: UserProfilesAggregate;
  /** fetch data from the table: "user_profiles" using primary key columns */
  readonly user_profiles_by_pk?: Maybe<UserProfiles>;
  /** fetch data from the table in a streaming manner: "user_profiles" */
  readonly user_profiles_stream: ReadonlyArray<UserProfiles>;
  /** fetch data from the table: "votes" */
  readonly votes: ReadonlyArray<Votes>;
  /** fetch aggregated fields from the table: "votes" */
  readonly votes_aggregate: VotesAggregate;
  /** fetch data from the table: "votes" using primary key columns */
  readonly votes_by_pk?: Maybe<Votes>;
  /** fetch data from the table in a streaming manner: "votes" */
  readonly votes_stream: ReadonlyArray<Votes>;
  /** fetch data from the table: "workflows" */
  readonly workflows: ReadonlyArray<Workflows>;
  /** fetch aggregated fields from the table: "workflows" */
  readonly workflows_aggregate: WorkflowsAggregate;
  /** fetch data from the table: "workflows" using primary key columns */
  readonly workflows_by_pk?: Maybe<Workflows>;
  /** fetch data from the table in a streaming manner: "workflows" */
  readonly workflows_stream: ReadonlyArray<Workflows>;
}

export type SubscriptionRootAdDailyMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdDailyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdDailyMetricsOrderBy>>;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
};

export type SubscriptionRootAdDailyMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdDailyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdDailyMetricsOrderBy>>;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
};

export type SubscriptionRootAdDailyMetricsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootAdDailyMetricsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<AdDailyMetricsStreamCursorInput>>;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
};

export type SubscriptionRootAdPackagesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdPackagesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdPackagesOrderBy>>;
  where?: InputMaybe<AdPackagesBoolExp>;
};

export type SubscriptionRootAdPackagesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdPackagesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdPackagesOrderBy>>;
  where?: InputMaybe<AdPackagesBoolExp>;
};

export type SubscriptionRootAdPackagesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootAdPackagesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<AdPackagesStreamCursorInput>>;
  where?: InputMaybe<AdPackagesBoolExp>;
};

export type SubscriptionRootAdVariantsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdVariantsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdVariantsOrderBy>>;
  where?: InputMaybe<AdVariantsBoolExp>;
};

export type SubscriptionRootAdVariantsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdVariantsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdVariantsOrderBy>>;
  where?: InputMaybe<AdVariantsBoolExp>;
};

export type SubscriptionRootAdVariantsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootAdVariantsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<AdVariantsStreamCursorInput>>;
  where?: InputMaybe<AdVariantsBoolExp>;
};

export type SubscriptionRootAddressesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

export type SubscriptionRootAddressesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AddressesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AddressesOrderBy>>;
  where?: InputMaybe<AddressesBoolExp>;
};

export type SubscriptionRootAddressesByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootAddressesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<AddressesStreamCursorInput>>;
  where?: InputMaybe<AddressesBoolExp>;
};

export type SubscriptionRootAdsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdsOrderBy>>;
  where?: InputMaybe<AdsBoolExp>;
};

export type SubscriptionRootAdsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<AdsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdsOrderBy>>;
  where?: InputMaybe<AdsBoolExp>;
};

export type SubscriptionRootAdsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootAdsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<AdsStreamCursorInput>>;
  where?: InputMaybe<AdsBoolExp>;
};

export type SubscriptionRootBlacklistedDomainsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BlacklistedDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BlacklistedDomainsOrderBy>>;
  where?: InputMaybe<BlacklistedDomainsBoolExp>;
};

export type SubscriptionRootBlacklistedDomainsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BlacklistedDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BlacklistedDomainsOrderBy>>;
  where?: InputMaybe<BlacklistedDomainsBoolExp>;
};

export type SubscriptionRootBlacklistedDomainsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootBlacklistedDomainsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<BlacklistedDomainsStreamCursorInput>>;
  where?: InputMaybe<BlacklistedDomainsBoolExp>;
};

export type SubscriptionRootBlacklistedUrlsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BlacklistedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BlacklistedUrlsOrderBy>>;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
};

export type SubscriptionRootBlacklistedUrlsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BlacklistedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BlacklistedUrlsOrderBy>>;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
};

export type SubscriptionRootBlacklistedUrlsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootBlacklistedUrlsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<BlacklistedUrlsStreamCursorInput>>;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
};

export type SubscriptionRootBlockedIpsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BlockedIpsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BlockedIpsOrderBy>>;
  where?: InputMaybe<BlockedIpsBoolExp>;
};

export type SubscriptionRootBlockedIpsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BlockedIpsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BlockedIpsOrderBy>>;
  where?: InputMaybe<BlockedIpsBoolExp>;
};

export type SubscriptionRootBlockedIpsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootBlockedIpsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<BlockedIpsStreamCursorInput>>;
  where?: InputMaybe<BlockedIpsBoolExp>;
};

export type SubscriptionRootBookmarkFoldersArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BookmarkFoldersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BookmarkFoldersOrderBy>>;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
};

export type SubscriptionRootBookmarkFoldersAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BookmarkFoldersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BookmarkFoldersOrderBy>>;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
};

export type SubscriptionRootBookmarkFoldersByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootBookmarkFoldersStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<BookmarkFoldersStreamCursorInput>>;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
};

export type SubscriptionRootBookmarksArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BookmarksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BookmarksOrderBy>>;
  where?: InputMaybe<BookmarksBoolExp>;
};

export type SubscriptionRootBookmarksAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BookmarksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BookmarksOrderBy>>;
  where?: InputMaybe<BookmarksBoolExp>;
};

export type SubscriptionRootBookmarksByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootBookmarksStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<BookmarksStreamCursorInput>>;
  where?: InputMaybe<BookmarksBoolExp>;
};

export type SubscriptionRootBusinessDomainsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BusinessDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BusinessDomainsOrderBy>>;
  where?: InputMaybe<BusinessDomainsBoolExp>;
};

export type SubscriptionRootBusinessDomainsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<BusinessDomainsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BusinessDomainsOrderBy>>;
  where?: InputMaybe<BusinessDomainsBoolExp>;
};

export type SubscriptionRootBusinessDomainsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootBusinessDomainsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<BusinessDomainsStreamCursorInput>>;
  where?: InputMaybe<BusinessDomainsBoolExp>;
};

export type SubscriptionRootCategoriesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CategoriesOrderBy>>;
  where?: InputMaybe<CategoriesBoolExp>;
};

export type SubscriptionRootCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CategoriesOrderBy>>;
  where?: InputMaybe<CategoriesBoolExp>;
};

export type SubscriptionRootCategoriesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootCategoriesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CategoriesStreamCursorInput>>;
  where?: InputMaybe<CategoriesBoolExp>;
};

export type SubscriptionRootCategorizedUrlsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CategorizedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CategorizedUrlsOrderBy>>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
};

export type SubscriptionRootCategorizedUrlsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CategorizedUrlsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CategorizedUrlsOrderBy>>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
};

export type SubscriptionRootCategorizedUrlsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootCategorizedUrlsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CategorizedUrlsStreamCursorInput>>;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
};

export type SubscriptionRootCircuitBreakerStatesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CircuitBreakerStatesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CircuitBreakerStatesOrderBy>>;
  where?: InputMaybe<CircuitBreakerStatesBoolExp>;
};

export type SubscriptionRootCircuitBreakerStatesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CircuitBreakerStatesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CircuitBreakerStatesOrderBy>>;
  where?: InputMaybe<CircuitBreakerStatesBoolExp>;
};

export type SubscriptionRootCircuitBreakerStatesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootCircuitBreakerStatesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CircuitBreakerStatesStreamCursorInput>>;
  where?: InputMaybe<CircuitBreakerStatesBoolExp>;
};

export type SubscriptionRootCitiesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CitiesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CitiesOrderBy>>;
  where?: InputMaybe<CitiesBoolExp>;
};

export type SubscriptionRootCitiesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CitiesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CitiesOrderBy>>;
  where?: InputMaybe<CitiesBoolExp>;
};

export type SubscriptionRootCitiesByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCitiesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CitiesStreamCursorInput>>;
  where?: InputMaybe<CitiesBoolExp>;
};

export type SubscriptionRootCommentsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CommentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CommentsOrderBy>>;
  where?: InputMaybe<CommentsBoolExp>;
};

export type SubscriptionRootCommentsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CommentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CommentsOrderBy>>;
  where?: InputMaybe<CommentsBoolExp>;
};

export type SubscriptionRootCommentsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootCommentsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CommentsStreamCursorInput>>;
  where?: InputMaybe<CommentsBoolExp>;
};

export type SubscriptionRootCompaniesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompaniesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompaniesOrderBy>>;
  where?: InputMaybe<CompaniesBoolExp>;
};

export type SubscriptionRootCompaniesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompaniesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompaniesOrderBy>>;
  where?: InputMaybe<CompaniesBoolExp>;
};

export type SubscriptionRootCompaniesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootCompaniesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CompaniesStreamCursorInput>>;
  where?: InputMaybe<CompaniesBoolExp>;
};

export type SubscriptionRootCompanyContactsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyContactsOrderBy>>;
  where?: InputMaybe<CompanyContactsBoolExp>;
};

export type SubscriptionRootCompanyContactsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyContactsOrderBy>>;
  where?: InputMaybe<CompanyContactsBoolExp>;
};

export type SubscriptionRootCompanyContactsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCompanyContactsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CompanyContactsStreamCursorInput>>;
  where?: InputMaybe<CompanyContactsBoolExp>;
};

export type SubscriptionRootCompanyEmployeesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyEmployeesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyEmployeesOrderBy>>;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
};

export type SubscriptionRootCompanyEmployeesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyEmployeesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyEmployeesOrderBy>>;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
};

export type SubscriptionRootCompanyEmployeesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootCompanyEmployeesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CompanyEmployeesStreamCursorInput>>;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
};

export type SubscriptionRootCompanyExtrasArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyExtrasSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyExtrasOrderBy>>;
  where?: InputMaybe<CompanyExtrasBoolExp>;
};

export type SubscriptionRootCompanyExtrasAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyExtrasSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyExtrasOrderBy>>;
  where?: InputMaybe<CompanyExtrasBoolExp>;
};

export type SubscriptionRootCompanyExtrasByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCompanyExtrasStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CompanyExtrasStreamCursorInput>>;
  where?: InputMaybe<CompanyExtrasBoolExp>;
};

export type SubscriptionRootCompanyMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyMetricsOrderBy>>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
};

export type SubscriptionRootCompanyMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyMetricsOrderBy>>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
};

export type SubscriptionRootCompanyMetricsByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootCompanyMetricsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CompanyMetricsStreamCursorInput>>;
  where?: InputMaybe<CompanyMetricsBoolExp>;
};

export type SubscriptionRootContactsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContactsOrderBy>>;
  where?: InputMaybe<ContactsBoolExp>;
};

export type SubscriptionRootContactsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContactsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContactsOrderBy>>;
  where?: InputMaybe<ContactsBoolExp>;
};

export type SubscriptionRootContactsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootContactsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ContactsStreamCursorInput>>;
  where?: InputMaybe<ContactsBoolExp>;
};

export type SubscriptionRootContentCategoriesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentCategoriesOrderBy>>;
  where?: InputMaybe<ContentCategoriesBoolExp>;
};

export type SubscriptionRootContentCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<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: ReadonlyArray<InputMaybe<ContentCategoriesStreamCursorInput>>;
  where?: InputMaybe<ContentCategoriesBoolExp>;
};

export type SubscriptionRootContentScoresArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentScoresSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentScoresOrderBy>>;
  where?: InputMaybe<ContentScoresBoolExp>;
};

export type SubscriptionRootContentScoresAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentScoresSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentScoresOrderBy>>;
  where?: InputMaybe<ContentScoresBoolExp>;
};

export type SubscriptionRootContentScoresStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ContentScoresStreamCursorInput>>;
  where?: InputMaybe<ContentScoresBoolExp>;
};

export type SubscriptionRootContentSourceVisitsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

export type SubscriptionRootContentSourceVisitsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

export type SubscriptionRootContentSourceVisitsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootContentSourceVisitsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ContentSourceVisitsStreamCursorInput>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

export type SubscriptionRootContentSourcesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentSourcesOrderBy>>;
  where?: InputMaybe<ContentSourcesBoolExp>;
};

export type SubscriptionRootContentSourcesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentSourcesOrderBy>>;
  where?: InputMaybe<ContentSourcesBoolExp>;
};

export type SubscriptionRootContentSourcesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootContentSourcesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ContentSourcesStreamCursorInput>>;
  where?: InputMaybe<ContentSourcesBoolExp>;
};

export type SubscriptionRootContentStatusesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentStatusesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentStatusesOrderBy>>;
  where?: InputMaybe<ContentStatusesBoolExp>;
};

export type SubscriptionRootContentStatusesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentStatusesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentStatusesOrderBy>>;
  where?: InputMaybe<ContentStatusesBoolExp>;
};

export type SubscriptionRootContentStatusesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootContentStatusesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ContentStatusesStreamCursorInput>>;
  where?: InputMaybe<ContentStatusesBoolExp>;
};

export type SubscriptionRootContentTagsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentTagsOrderBy>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

export type SubscriptionRootContentTagsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<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: ReadonlyArray<InputMaybe<ContentTagsStreamCursorInput>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

export type SubscriptionRootContentsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentsOrderBy>>;
  where?: InputMaybe<ContentsBoolExp>;
};

export type SubscriptionRootContentsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentsOrderBy>>;
  where?: InputMaybe<ContentsBoolExp>;
};

export type SubscriptionRootContentsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootContentsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ContentsStreamCursorInput>>;
  where?: InputMaybe<ContentsBoolExp>;
};

export type SubscriptionRootCountriesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CountriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CountriesOrderBy>>;
  where?: InputMaybe<CountriesBoolExp>;
};

export type SubscriptionRootCountriesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CountriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CountriesOrderBy>>;
  where?: InputMaybe<CountriesBoolExp>;
};

export type SubscriptionRootCountriesByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCountriesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CountriesStreamCursorInput>>;
  where?: InputMaybe<CountriesBoolExp>;
};

export type SubscriptionRootCustomerPaymentsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

export type SubscriptionRootCustomerPaymentsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

export type SubscriptionRootCustomerPaymentsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCustomerPaymentsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CustomerPaymentsStreamCursorInput>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

export type SubscriptionRootCustomerProcessedWebhooksArgs = {
  distinct_on?: InputMaybe<
    ReadonlyArray<CustomerProcessedWebhooksSelectColumn>
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerProcessedWebhooksOrderBy>>;
  where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
};

export type SubscriptionRootCustomerProcessedWebhooksAggregateArgs = {
  distinct_on?: InputMaybe<
    ReadonlyArray<CustomerProcessedWebhooksSelectColumn>
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerProcessedWebhooksOrderBy>>;
  where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
};

export type SubscriptionRootCustomerProcessedWebhooksByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCustomerProcessedWebhooksStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CustomerProcessedWebhooksStreamCursorInput>>;
  where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
};

export type SubscriptionRootCustomerRefundsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerRefundsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerRefundsOrderBy>>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
};

export type SubscriptionRootCustomerRefundsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerRefundsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerRefundsOrderBy>>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
};

export type SubscriptionRootCustomerRefundsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCustomerRefundsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CustomerRefundsStreamCursorInput>>;
  where?: InputMaybe<CustomerRefundsBoolExp>;
};

export type SubscriptionRootCustomerSubscriptionPlansArgs = {
  distinct_on?: InputMaybe<
    ReadonlyArray<CustomerSubscriptionPlansSelectColumn>
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerSubscriptionPlansOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
};

export type SubscriptionRootCustomerSubscriptionPlansAggregateArgs = {
  distinct_on?: InputMaybe<
    ReadonlyArray<CustomerSubscriptionPlansSelectColumn>
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerSubscriptionPlansOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
};

export type SubscriptionRootCustomerSubscriptionPlansByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCustomerSubscriptionPlansStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CustomerSubscriptionPlansStreamCursorInput>>;
  where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
};

export type SubscriptionRootCustomerSubscriptionsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

export type SubscriptionRootCustomerSubscriptionsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

export type SubscriptionRootCustomerSubscriptionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootCustomerSubscriptionsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<CustomerSubscriptionsStreamCursorInput>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

export type SubscriptionRootEmbeddingReviewsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<EmbeddingReviewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<EmbeddingReviewsOrderBy>>;
  where?: InputMaybe<EmbeddingReviewsBoolExp>;
};

export type SubscriptionRootEmbeddingReviewsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<EmbeddingReviewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<EmbeddingReviewsOrderBy>>;
  where?: InputMaybe<EmbeddingReviewsBoolExp>;
};

export type SubscriptionRootEmbeddingReviewsByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootEmbeddingReviewsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<EmbeddingReviewsStreamCursorInput>>;
  where?: InputMaybe<EmbeddingReviewsBoolExp>;
};

export type SubscriptionRootErrorCorrelationsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorCorrelationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorCorrelationsOrderBy>>;
  where?: InputMaybe<ErrorCorrelationsBoolExp>;
};

export type SubscriptionRootErrorCorrelationsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorCorrelationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorCorrelationsOrderBy>>;
  where?: InputMaybe<ErrorCorrelationsBoolExp>;
};

export type SubscriptionRootErrorCorrelationsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ErrorCorrelationsStreamCursorInput>>;
  where?: InputMaybe<ErrorCorrelationsBoolExp>;
};

export type SubscriptionRootErrorFrequencyArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorFrequencySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorFrequencyOrderBy>>;
  where?: InputMaybe<ErrorFrequencyBoolExp>;
};

export type SubscriptionRootErrorFrequencyAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorFrequencySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorFrequencyOrderBy>>;
  where?: InputMaybe<ErrorFrequencyBoolExp>;
};

export type SubscriptionRootErrorFrequencyStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ErrorFrequencyStreamCursorInput>>;
  where?: InputMaybe<ErrorFrequencyBoolExp>;
};

export type SubscriptionRootErrorLogsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorLogsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorLogsOrderBy>>;
  where?: InputMaybe<ErrorLogsBoolExp>;
};

export type SubscriptionRootErrorLogsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorLogsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorLogsOrderBy>>;
  where?: InputMaybe<ErrorLogsBoolExp>;
};

export type SubscriptionRootErrorLogsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootErrorLogsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ErrorLogsStreamCursorInput>>;
  where?: InputMaybe<ErrorLogsBoolExp>;
};

export type SubscriptionRootErrorMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorMetricsOrderBy>>;
  where?: InputMaybe<ErrorMetricsBoolExp>;
};

export type SubscriptionRootErrorMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorMetricsOrderBy>>;
  where?: InputMaybe<ErrorMetricsBoolExp>;
};

export type SubscriptionRootErrorMetricsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ErrorMetricsStreamCursorInput>>;
  where?: InputMaybe<ErrorMetricsBoolExp>;
};

export type SubscriptionRootErrorPatternsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorPatternsOrderBy>>;
  where?: InputMaybe<ErrorPatternsBoolExp>;
};

export type SubscriptionRootErrorPatternsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorPatternsOrderBy>>;
  where?: InputMaybe<ErrorPatternsBoolExp>;
};

export type SubscriptionRootErrorPatternsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ErrorPatternsStreamCursorInput>>;
  where?: InputMaybe<ErrorPatternsBoolExp>;
};

export type SubscriptionRootErrorStatsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorStatsOrderBy>>;
  where?: InputMaybe<ErrorStatsBoolExp>;
};

export type SubscriptionRootErrorStatsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ErrorStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorStatsOrderBy>>;
  where?: InputMaybe<ErrorStatsBoolExp>;
};

export type SubscriptionRootErrorStatsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ErrorStatsStreamCursorInput>>;
  where?: InputMaybe<ErrorStatsBoolExp>;
};

export type SubscriptionRootFeatureRequestsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeatureRequestsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeatureRequestsOrderBy>>;
  where?: InputMaybe<FeatureRequestsBoolExp>;
};

export type SubscriptionRootFeatureRequestsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeatureRequestsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeatureRequestsOrderBy>>;
  where?: InputMaybe<FeatureRequestsBoolExp>;
};

export type SubscriptionRootFeatureRequestsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootFeatureRequestsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<FeatureRequestsStreamCursorInput>>;
  where?: InputMaybe<FeatureRequestsBoolExp>;
};

export type SubscriptionRootFeatureVotesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeatureVotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeatureVotesOrderBy>>;
  where?: InputMaybe<FeatureVotesBoolExp>;
};

export type SubscriptionRootFeatureVotesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeatureVotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeatureVotesOrderBy>>;
  where?: InputMaybe<FeatureVotesBoolExp>;
};

export type SubscriptionRootFeatureVotesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootFeatureVotesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<FeatureVotesStreamCursorInput>>;
  where?: InputMaybe<FeatureVotesBoolExp>;
};

export type SubscriptionRootFeedCategoriesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedCategoriesOrderBy>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

export type SubscriptionRootFeedCategoriesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedCategoriesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedCategoriesOrderBy>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

export type SubscriptionRootFeedCategoriesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootFeedCategoriesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<FeedCategoriesStreamCursorInput>>;
  where?: InputMaybe<FeedCategoriesBoolExp>;
};

export type SubscriptionRootFeedSourcesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

export type SubscriptionRootFeedSourcesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedSourcesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedSourcesOrderBy>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

export type SubscriptionRootFeedSourcesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootFeedSourcesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<FeedSourcesStreamCursorInput>>;
  where?: InputMaybe<FeedSourcesBoolExp>;
};

export type SubscriptionRootFeedbacksArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedbacksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedbacksOrderBy>>;
  where?: InputMaybe<FeedbacksBoolExp>;
};

export type SubscriptionRootFeedbacksAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedbacksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedbacksOrderBy>>;
  where?: InputMaybe<FeedbacksBoolExp>;
};

export type SubscriptionRootFeedbacksByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootFeedbacksStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<FeedbacksStreamCursorInput>>;
  where?: InputMaybe<FeedbacksBoolExp>;
};

export type SubscriptionRootFeedsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedsOrderBy>>;
  where?: InputMaybe<FeedsBoolExp>;
};

export type SubscriptionRootFeedsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedsOrderBy>>;
  where?: InputMaybe<FeedsBoolExp>;
};

export type SubscriptionRootFeedsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootFeedsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<FeedsStreamCursorInput>>;
  where?: InputMaybe<FeedsBoolExp>;
};

export type SubscriptionRootFollowsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FollowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FollowsOrderBy>>;
  where?: InputMaybe<FollowsBoolExp>;
};

export type SubscriptionRootFollowsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FollowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FollowsOrderBy>>;
  where?: InputMaybe<FollowsBoolExp>;
};

export type SubscriptionRootFollowsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootFollowsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<FollowsStreamCursorInput>>;
  where?: InputMaybe<FollowsBoolExp>;
};

export type SubscriptionRootMetricDefinitionsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<MetricDefinitionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<MetricDefinitionsOrderBy>>;
  where?: InputMaybe<MetricDefinitionsBoolExp>;
};

export type SubscriptionRootMetricDefinitionsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<MetricDefinitionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<MetricDefinitionsOrderBy>>;
  where?: InputMaybe<MetricDefinitionsBoolExp>;
};

export type SubscriptionRootMetricDefinitionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootMetricDefinitionsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<MetricDefinitionsStreamCursorInput>>;
  where?: InputMaybe<MetricDefinitionsBoolExp>;
};

export type SubscriptionRootNewsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsOrderBy>>;
  where?: InputMaybe<NewsBoolExp>;
};

export type SubscriptionRootNewsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsOrderBy>>;
  where?: InputMaybe<NewsBoolExp>;
};

export type SubscriptionRootNewsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootNewsDetailsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsDetailsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsDetailsOrderBy>>;
  where?: InputMaybe<NewsDetailsBoolExp>;
};

export type SubscriptionRootNewsDetailsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsDetailsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsDetailsOrderBy>>;
  where?: InputMaybe<NewsDetailsBoolExp>;
};

export type SubscriptionRootNewsDetailsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<NewsDetailsStreamCursorInput>>;
  where?: InputMaybe<NewsDetailsBoolExp>;
};

export type SubscriptionRootNewsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<NewsStreamCursorInput>>;
  where?: InputMaybe<NewsBoolExp>;
};

export type SubscriptionRootNewsSummariesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsSummariesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsSummariesOrderBy>>;
  where?: InputMaybe<NewsSummariesBoolExp>;
};

export type SubscriptionRootNewsSummariesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsSummariesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsSummariesOrderBy>>;
  where?: InputMaybe<NewsSummariesBoolExp>;
};

export type SubscriptionRootNewsSummariesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootNewsSummariesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<NewsSummariesStreamCursorInput>>;
  where?: InputMaybe<NewsSummariesBoolExp>;
};

export type SubscriptionRootNewsTagsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsTagsOrderBy>>;
  where?: InputMaybe<NewsTagsBoolExp>;
};

export type SubscriptionRootNewsTagsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsTagsOrderBy>>;
  where?: InputMaybe<NewsTagsBoolExp>;
};

export type SubscriptionRootNewsTagsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootNewsTagsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<NewsTagsStreamCursorInput>>;
  where?: InputMaybe<NewsTagsBoolExp>;
};

export type SubscriptionRootNewslettersArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewslettersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewslettersOrderBy>>;
  where?: InputMaybe<NewslettersBoolExp>;
};

export type SubscriptionRootNewslettersAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewslettersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewslettersOrderBy>>;
  where?: InputMaybe<NewslettersBoolExp>;
};

export type SubscriptionRootNewslettersByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootNewslettersStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<NewslettersStreamCursorInput>>;
  where?: InputMaybe<NewslettersBoolExp>;
};

export type SubscriptionRootPaymentProvidersArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<PaymentProvidersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<PaymentProvidersOrderBy>>;
  where?: InputMaybe<PaymentProvidersBoolExp>;
};

export type SubscriptionRootPaymentProvidersAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<PaymentProvidersSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<PaymentProvidersOrderBy>>;
  where?: InputMaybe<PaymentProvidersBoolExp>;
};

export type SubscriptionRootPaymentProvidersByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootPaymentProvidersStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<PaymentProvidersStreamCursorInput>>;
  where?: InputMaybe<PaymentProvidersBoolExp>;
};

export type SubscriptionRootPlanPermissionsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<PlanPermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<PlanPermissionsOrderBy>>;
  where?: InputMaybe<PlanPermissionsBoolExp>;
};

export type SubscriptionRootPlanPermissionsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<PlanPermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<PlanPermissionsOrderBy>>;
  where?: InputMaybe<PlanPermissionsBoolExp>;
};

export type SubscriptionRootPlanPermissionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootPlanPermissionsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<PlanPermissionsStreamCursorInput>>;
  where?: InputMaybe<PlanPermissionsBoolExp>;
};

export type SubscriptionRootRecentErrorsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<RecentErrorsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<RecentErrorsOrderBy>>;
  where?: InputMaybe<RecentErrorsBoolExp>;
};

export type SubscriptionRootRecentErrorsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<RecentErrorsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<RecentErrorsOrderBy>>;
  where?: InputMaybe<RecentErrorsBoolExp>;
};

export type SubscriptionRootRecentErrorsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<RecentErrorsStreamCursorInput>>;
  where?: InputMaybe<RecentErrorsBoolExp>;
};

export type SubscriptionRootReferralStatsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferralStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferralStatsOrderBy>>;
  where?: InputMaybe<ReferralStatsBoolExp>;
};

export type SubscriptionRootReferralStatsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferralStatsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferralStatsOrderBy>>;
  where?: InputMaybe<ReferralStatsBoolExp>;
};

export type SubscriptionRootReferralStatsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ReferralStatsStreamCursorInput>>;
  where?: InputMaybe<ReferralStatsBoolExp>;
};

export type SubscriptionRootReferralsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferralsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferralsOrderBy>>;
  where?: InputMaybe<ReferralsBoolExp>;
};

export type SubscriptionRootReferralsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferralsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferralsOrderBy>>;
  where?: InputMaybe<ReferralsBoolExp>;
};

export type SubscriptionRootReferralsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootReferralsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ReferralsStreamCursorInput>>;
  where?: InputMaybe<ReferralsBoolExp>;
};

export type SubscriptionRootReferrerBlocksArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferrerBlocksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferrerBlocksOrderBy>>;
  where?: InputMaybe<ReferrerBlocksBoolExp>;
};

export type SubscriptionRootReferrerBlocksAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferrerBlocksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferrerBlocksOrderBy>>;
  where?: InputMaybe<ReferrerBlocksBoolExp>;
};

export type SubscriptionRootReferrerBlocksByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootReferrerBlocksStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ReferrerBlocksStreamCursorInput>>;
  where?: InputMaybe<ReferrerBlocksBoolExp>;
};

export type SubscriptionRootReferrerRiskMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferrerRiskMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferrerRiskMetricsOrderBy>>;
  where?: InputMaybe<ReferrerRiskMetricsBoolExp>;
};

export type SubscriptionRootReferrerRiskMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ReferrerRiskMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferrerRiskMetricsOrderBy>>;
  where?: InputMaybe<ReferrerRiskMetricsBoolExp>;
};

export type SubscriptionRootReferrerRiskMetricsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ReferrerRiskMetricsStreamCursorInput>>;
  where?: InputMaybe<ReferrerRiskMetricsBoolExp>;
};

export type SubscriptionRootResearchArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResearchSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResearchOrderBy>>;
  where?: InputMaybe<ResearchBoolExp>;
};

export type SubscriptionRootResearchAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResearchSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResearchOrderBy>>;
  where?: InputMaybe<ResearchBoolExp>;
};

export type SubscriptionRootResearchByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootResearchEmbeddingsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResearchEmbeddingsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResearchEmbeddingsOrderBy>>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

export type SubscriptionRootResearchEmbeddingsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResearchEmbeddingsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResearchEmbeddingsOrderBy>>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

export type SubscriptionRootResearchEmbeddingsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootResearchEmbeddingsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ResearchEmbeddingsStreamCursorInput>>;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
};

export type SubscriptionRootResearchStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ResearchStreamCursorInput>>;
  where?: InputMaybe<ResearchBoolExp>;
};

export type SubscriptionRootResponsesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResponsesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResponsesOrderBy>>;
  where?: InputMaybe<ResponsesBoolExp>;
};

export type SubscriptionRootResponsesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ResponsesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResponsesOrderBy>>;
  where?: InputMaybe<ResponsesBoolExp>;
};

export type SubscriptionRootResponsesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootResponsesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ResponsesStreamCursorInput>>;
  where?: InputMaybe<ResponsesBoolExp>;
};

export type SubscriptionRootRoleHierarchyArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<RoleHierarchySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<RoleHierarchyOrderBy>>;
  where?: InputMaybe<RoleHierarchyBoolExp>;
};

export type SubscriptionRootRoleHierarchyAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<RoleHierarchySelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<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: ReadonlyArray<InputMaybe<RoleHierarchyStreamCursorInput>>;
  where?: InputMaybe<RoleHierarchyBoolExp>;
};

export type SubscriptionRootRolePermissionsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<RolePermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<RolePermissionsOrderBy>>;
  where?: InputMaybe<RolePermissionsBoolExp>;
};

export type SubscriptionRootRolePermissionsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<RolePermissionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<RolePermissionsOrderBy>>;
  where?: InputMaybe<RolePermissionsBoolExp>;
};

export type SubscriptionRootRolePermissionsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootRolePermissionsMaterializedArgs = {
  distinct_on?: InputMaybe<
    ReadonlyArray<RolePermissionsMaterializedSelectColumn>
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<RolePermissionsMaterializedOrderBy>>;
  where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
};

export type SubscriptionRootRolePermissionsMaterializedAggregateArgs = {
  distinct_on?: InputMaybe<
    ReadonlyArray<RolePermissionsMaterializedSelectColumn>
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<RolePermissionsMaterializedOrderBy>>;
  where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
};

export type SubscriptionRootRolePermissionsMaterializedByPkArgs = {
  role: Scalars["app_role_enum"]["input"];
};

export type SubscriptionRootRolePermissionsMaterializedStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<
    InputMaybe<RolePermissionsMaterializedStreamCursorInput>
  >;
  where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
};

export type SubscriptionRootRolePermissionsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<RolePermissionsStreamCursorInput>>;
  where?: InputMaybe<RolePermissionsBoolExp>;
};

export type SubscriptionRootScoringWeightsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ScoringWeightsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ScoringWeightsOrderBy>>;
  where?: InputMaybe<ScoringWeightsBoolExp>;
};

export type SubscriptionRootScoringWeightsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ScoringWeightsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ScoringWeightsOrderBy>>;
  where?: InputMaybe<ScoringWeightsBoolExp>;
};

export type SubscriptionRootScoringWeightsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootScoringWeightsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<ScoringWeightsStreamCursorInput>>;
  where?: InputMaybe<ScoringWeightsBoolExp>;
};

export type SubscriptionRootSearchesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SearchesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SearchesOrderBy>>;
  where?: InputMaybe<SearchesBoolExp>;
};

export type SubscriptionRootSearchesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SearchesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SearchesOrderBy>>;
  where?: InputMaybe<SearchesBoolExp>;
};

export type SubscriptionRootSearchesByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootSearchesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<SearchesStreamCursorInput>>;
  where?: InputMaybe<SearchesBoolExp>;
};

export type SubscriptionRootSecurityMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SecurityMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SecurityMetricsOrderBy>>;
  where?: InputMaybe<SecurityMetricsBoolExp>;
};

export type SubscriptionRootSecurityMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SecurityMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SecurityMetricsOrderBy>>;
  where?: InputMaybe<SecurityMetricsBoolExp>;
};

export type SubscriptionRootSecurityMetricsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<SecurityMetricsStreamCursorInput>>;
  where?: InputMaybe<SecurityMetricsBoolExp>;
};

export type SubscriptionRootSlowQueryPatternsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SlowQueryPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SlowQueryPatternsOrderBy>>;
  where?: InputMaybe<SlowQueryPatternsBoolExp>;
};

export type SubscriptionRootSlowQueryPatternsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SlowQueryPatternsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SlowQueryPatternsOrderBy>>;
  where?: InputMaybe<SlowQueryPatternsBoolExp>;
};

export type SubscriptionRootSlowQueryPatternsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<SlowQueryPatternsStreamCursorInput>>;
  where?: InputMaybe<SlowQueryPatternsBoolExp>;
};

export type SubscriptionRootSocialMediaArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SocialMediaSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SocialMediaOrderBy>>;
  where?: InputMaybe<SocialMediaBoolExp>;
};

export type SubscriptionRootSocialMediaAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SocialMediaSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SocialMediaOrderBy>>;
  where?: InputMaybe<SocialMediaBoolExp>;
};

export type SubscriptionRootSocialMediaByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootSocialMediaStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<SocialMediaStreamCursorInput>>;
  where?: InputMaybe<SocialMediaBoolExp>;
};

export type SubscriptionRootSpiderMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SpiderMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SpiderMetricsOrderBy>>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
};

export type SubscriptionRootSpiderMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<SpiderMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SpiderMetricsOrderBy>>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
};

export type SubscriptionRootSpiderMetricsByPkArgs = {
  id: Scalars["bigint"]["input"];
};

export type SubscriptionRootSpiderMetricsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<SpiderMetricsStreamCursorInput>>;
  where?: InputMaybe<SpiderMetricsBoolExp>;
};

export type SubscriptionRootStrapiMigrationsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<StrapiMigrationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<StrapiMigrationsOrderBy>>;
  where?: InputMaybe<StrapiMigrationsBoolExp>;
};

export type SubscriptionRootStrapiMigrationsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<StrapiMigrationsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<StrapiMigrationsOrderBy>>;
  where?: InputMaybe<StrapiMigrationsBoolExp>;
};

export type SubscriptionRootStrapiMigrationsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootStrapiMigrationsInternalArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<StrapiMigrationsInternalSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<StrapiMigrationsInternalOrderBy>>;
  where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
};

export type SubscriptionRootStrapiMigrationsInternalAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<StrapiMigrationsInternalSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<StrapiMigrationsInternalOrderBy>>;
  where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
};

export type SubscriptionRootStrapiMigrationsInternalByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootStrapiMigrationsInternalStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<StrapiMigrationsInternalStreamCursorInput>>;
  where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
};

export type SubscriptionRootStrapiMigrationsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<StrapiMigrationsStreamCursorInput>>;
  where?: InputMaybe<StrapiMigrationsBoolExp>;
};

export type SubscriptionRootTableMaintenanceLogArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableMaintenanceLogSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TableMaintenanceLogOrderBy>>;
  where?: InputMaybe<TableMaintenanceLogBoolExp>;
};

export type SubscriptionRootTableMaintenanceLogAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableMaintenanceLogSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TableMaintenanceLogOrderBy>>;
  where?: InputMaybe<TableMaintenanceLogBoolExp>;
};

export type SubscriptionRootTableMaintenanceLogByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootTableMaintenanceLogStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<TableMaintenanceLogStreamCursorInput>>;
  where?: InputMaybe<TableMaintenanceLogBoolExp>;
};

export type SubscriptionRootTableQueryPerformanceArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableQueryPerformanceSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TableQueryPerformanceOrderBy>>;
  where?: InputMaybe<TableQueryPerformanceBoolExp>;
};

export type SubscriptionRootTableQueryPerformanceAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableQueryPerformanceSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TableQueryPerformanceOrderBy>>;
  where?: InputMaybe<TableQueryPerformanceBoolExp>;
};

export type SubscriptionRootTableQueryPerformanceStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<TableQueryPerformanceStreamCursorInput>>;
  where?: InputMaybe<TableQueryPerformanceBoolExp>;
};

export type SubscriptionRootTableSequenceUsageArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableSequenceUsageSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TableSequenceUsageOrderBy>>;
  where?: InputMaybe<TableSequenceUsageBoolExp>;
};

export type SubscriptionRootTableSequenceUsageAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableSequenceUsageSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TableSequenceUsageOrderBy>>;
  where?: InputMaybe<TableSequenceUsageBoolExp>;
};

export type SubscriptionRootTableSequenceUsageStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<TableSequenceUsageStreamCursorInput>>;
  where?: InputMaybe<TableSequenceUsageBoolExp>;
};

export type SubscriptionRootTableStatisticsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableStatisticsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TableStatisticsOrderBy>>;
  where?: InputMaybe<TableStatisticsBoolExp>;
};

export type SubscriptionRootTableStatisticsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TableStatisticsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<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: ReadonlyArray<InputMaybe<TableStatisticsStreamCursorInput>>;
  where?: InputMaybe<TableStatisticsBoolExp>;
};

export type SubscriptionRootTagsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TagsOrderBy>>;
  where?: InputMaybe<TagsBoolExp>;
};

export type SubscriptionRootTagsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<TagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TagsOrderBy>>;
  where?: InputMaybe<TagsBoolExp>;
};

export type SubscriptionRootTagsByPkArgs = {
  id: Scalars["Int"]["input"];
};

export type SubscriptionRootTagsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<TagsStreamCursorInput>>;
  where?: InputMaybe<TagsBoolExp>;
};

export type SubscriptionRootUserMetricsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<UserMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<UserMetricsOrderBy>>;
  where?: InputMaybe<UserMetricsBoolExp>;
};

export type SubscriptionRootUserMetricsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<UserMetricsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<UserMetricsOrderBy>>;
  where?: InputMaybe<UserMetricsBoolExp>;
};

export type SubscriptionRootUserMetricsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootUserMetricsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<UserMetricsStreamCursorInput>>;
  where?: InputMaybe<UserMetricsBoolExp>;
};

export type SubscriptionRootUserProfilesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<UserProfilesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<UserProfilesOrderBy>>;
  where?: InputMaybe<UserProfilesBoolExp>;
};

export type SubscriptionRootUserProfilesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<UserProfilesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<UserProfilesOrderBy>>;
  where?: InputMaybe<UserProfilesBoolExp>;
};

export type SubscriptionRootUserProfilesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootUserProfilesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<UserProfilesStreamCursorInput>>;
  where?: InputMaybe<UserProfilesBoolExp>;
};

export type SubscriptionRootVotesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<VotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<VotesOrderBy>>;
  where?: InputMaybe<VotesBoolExp>;
};

export type SubscriptionRootVotesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<VotesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<VotesOrderBy>>;
  where?: InputMaybe<VotesBoolExp>;
};

export type SubscriptionRootVotesByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootVotesStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<VotesStreamCursorInput>>;
  where?: InputMaybe<VotesBoolExp>;
};

export type SubscriptionRootWorkflowsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<WorkflowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<WorkflowsOrderBy>>;
  where?: InputMaybe<WorkflowsBoolExp>;
};

export type SubscriptionRootWorkflowsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<WorkflowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<WorkflowsOrderBy>>;
  where?: InputMaybe<WorkflowsBoolExp>;
};

export type SubscriptionRootWorkflowsByPkArgs = {
  id: Scalars["uuid"]["input"];
};

export type SubscriptionRootWorkflowsStreamArgs = {
  batch_size: Scalars["Int"]["input"];
  cursor: ReadonlyArray<InputMaybe<WorkflowsStreamCursorInput>>;
  where?: InputMaybe<WorkflowsBoolExp>;
};

/** columns and relationships of "table_maintenance_log" */
export interface TableMaintenanceLog {
  readonly detail?: Maybe<Scalars["String"]["output"]>;
  readonly id: Scalars["Int"]["output"];
  readonly logged_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly operation?: Maybe<Scalars["String"]["output"]>;
}

/** aggregated selection of "table_maintenance_log" */
export interface TableMaintenanceLogAggregate {
  readonly aggregate?: Maybe<TableMaintenanceLogAggregateFields>;
  readonly nodes: ReadonlyArray<TableMaintenanceLog>;
}

/** aggregate fields of "table_maintenance_log" */
export interface TableMaintenanceLogAggregateFields {
  readonly avg?: Maybe<TableMaintenanceLogAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<TableMaintenanceLogMaxFields>;
  readonly min?: Maybe<TableMaintenanceLogMinFields>;
  readonly stddev?: Maybe<TableMaintenanceLogStddevFields>;
  readonly stddev_pop?: Maybe<TableMaintenanceLogStddevPopFields>;
  readonly stddev_samp?: Maybe<TableMaintenanceLogStddevSampFields>;
  readonly sum?: Maybe<TableMaintenanceLogSumFields>;
  readonly var_pop?: Maybe<TableMaintenanceLogVarPopFields>;
  readonly var_samp?: Maybe<TableMaintenanceLogVarSampFields>;
  readonly variance?: Maybe<TableMaintenanceLogVarianceFields>;
}

/** aggregate fields of "table_maintenance_log" */
export type TableMaintenanceLogAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<TableMaintenanceLogSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface TableMaintenanceLogAvgFields {
  readonly 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 interface TableMaintenanceLogBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<TableMaintenanceLogBoolExp>>;
  readonly _not?: InputMaybe<TableMaintenanceLogBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<TableMaintenanceLogBoolExp>>;
  readonly detail?: InputMaybe<StringComparisonExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly logged_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly operation?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "table_maintenance_log" */
export type TableMaintenanceLogConstraint =
  /** unique or primary key constraint on columns "id" */
  "table_maintenance_log_pkey";

/** input type for incrementing numeric columns in table "table_maintenance_log" */
export interface TableMaintenanceLogIncInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "table_maintenance_log" */
export interface TableMaintenanceLogInsertInput {
  readonly detail?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly logged_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly operation?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate max on columns */
export interface TableMaintenanceLogMaxFields {
  readonly detail?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly logged_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly operation?: Maybe<Scalars["String"]["output"]>;
}

/** aggregate min on columns */
export interface TableMaintenanceLogMinFields {
  readonly detail?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly logged_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly operation?: Maybe<Scalars["String"]["output"]>;
}

/** response of any mutation on the table "table_maintenance_log" */
export interface TableMaintenanceLogMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<TableMaintenanceLog>;
}

/** on_conflict condition type for table "table_maintenance_log" */
export interface TableMaintenanceLogOnConflict {
  readonly constraint: TableMaintenanceLogConstraint;
  readonly update_columns: ReadonlyArray<TableMaintenanceLogUpdateColumn>;
  readonly where?: InputMaybe<TableMaintenanceLogBoolExp>;
}

/** Ordering options when selecting data from "table_maintenance_log". */
export interface TableMaintenanceLogOrderBy {
  readonly detail?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly logged_at?: InputMaybe<OrderBy>;
  readonly operation?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: table_maintenance_log */
export interface TableMaintenanceLogPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** select columns of table "table_maintenance_log" */
export type TableMaintenanceLogSelectColumn =
  /** column name */
  | "detail"
  /** column name */
  | "id"
  /** column name */
  | "logged_at"
  /** column name */
  | "operation";

/** input type for updating data in table "table_maintenance_log" */
export interface TableMaintenanceLogSetInput {
  readonly detail?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly logged_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly operation?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate stddev on columns */
export interface TableMaintenanceLogStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface TableMaintenanceLogStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface TableMaintenanceLogStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "table_maintenance_log" */
export interface TableMaintenanceLogStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: TableMaintenanceLogStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface TableMaintenanceLogStreamCursorValueInput {
  readonly detail?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly logged_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly operation?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface TableMaintenanceLogSumFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "table_maintenance_log" */
export type TableMaintenanceLogUpdateColumn =
  /** column name */
  | "detail"
  /** column name */
  | "id"
  /** column name */
  | "logged_at"
  /** column name */
  | "operation";

export interface TableMaintenanceLogUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<TableMaintenanceLogIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<TableMaintenanceLogSetInput>;
  /** filter the rows which have to be updated */
  readonly where: TableMaintenanceLogBoolExp;
}

/** aggregate var_pop on columns */
export interface TableMaintenanceLogVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface TableMaintenanceLogVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface TableMaintenanceLogVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "table_query_performance" */
export interface TableQueryPerformance {
  readonly avg_duration?: Maybe<Scalars["interval"]["output"]>;
  readonly capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly execution_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly query?: Maybe<Scalars["String"]["output"]>;
}

/** aggregated selection of "table_query_performance" */
export interface TableQueryPerformanceAggregate {
  readonly aggregate?: Maybe<TableQueryPerformanceAggregateFields>;
  readonly nodes: ReadonlyArray<TableQueryPerformance>;
}

/** aggregate fields of "table_query_performance" */
export interface TableQueryPerformanceAggregateFields {
  readonly avg?: Maybe<TableQueryPerformanceAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<TableQueryPerformanceMaxFields>;
  readonly min?: Maybe<TableQueryPerformanceMinFields>;
  readonly stddev?: Maybe<TableQueryPerformanceStddevFields>;
  readonly stddev_pop?: Maybe<TableQueryPerformanceStddevPopFields>;
  readonly stddev_samp?: Maybe<TableQueryPerformanceStddevSampFields>;
  readonly sum?: Maybe<TableQueryPerformanceSumFields>;
  readonly var_pop?: Maybe<TableQueryPerformanceVarPopFields>;
  readonly var_samp?: Maybe<TableQueryPerformanceVarSampFields>;
  readonly variance?: Maybe<TableQueryPerformanceVarianceFields>;
}

/** aggregate fields of "table_query_performance" */
export type TableQueryPerformanceAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<TableQueryPerformanceSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface TableQueryPerformanceAvgFields {
  readonly 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 interface TableQueryPerformanceBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<TableQueryPerformanceBoolExp>>;
  readonly _not?: InputMaybe<TableQueryPerformanceBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<TableQueryPerformanceBoolExp>>;
  readonly avg_duration?: InputMaybe<IntervalComparisonExp>;
  readonly capture_time?: InputMaybe<TimestamptzComparisonExp>;
  readonly execution_count?: InputMaybe<BigintComparisonExp>;
  readonly query?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "table_query_performance" */
export type TableQueryPerformanceConstraint =
  /** unique or primary key constraint on columns "query", "capture_time" */
  "idx_query_performance_unique";

/** input type for incrementing numeric columns in table "table_query_performance" */
export interface TableQueryPerformanceIncInput {
  readonly execution_count?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** input type for inserting data into table "table_query_performance" */
export interface TableQueryPerformanceInsertInput {
  readonly avg_duration?: InputMaybe<Scalars["interval"]["input"]>;
  readonly capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly execution_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly query?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate max on columns */
export interface TableQueryPerformanceMaxFields {
  readonly capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly execution_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly query?: Maybe<Scalars["String"]["output"]>;
}

/** aggregate min on columns */
export interface TableQueryPerformanceMinFields {
  readonly capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly execution_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly query?: Maybe<Scalars["String"]["output"]>;
}

/** response of any mutation on the table "table_query_performance" */
export interface TableQueryPerformanceMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<TableQueryPerformance>;
}

/** on_conflict condition type for table "table_query_performance" */
export interface TableQueryPerformanceOnConflict {
  readonly constraint: TableQueryPerformanceConstraint;
  readonly update_columns: ReadonlyArray<TableQueryPerformanceUpdateColumn>;
  readonly where?: InputMaybe<TableQueryPerformanceBoolExp>;
}

/** Ordering options when selecting data from "table_query_performance". */
export interface TableQueryPerformanceOrderBy {
  readonly avg_duration?: InputMaybe<OrderBy>;
  readonly capture_time?: InputMaybe<OrderBy>;
  readonly execution_count?: InputMaybe<OrderBy>;
  readonly query?: InputMaybe<OrderBy>;
}

/** select columns of table "table_query_performance" */
export type TableQueryPerformanceSelectColumn =
  /** column name */
  | "avg_duration"
  /** column name */
  | "capture_time"
  /** column name */
  | "execution_count"
  /** column name */
  | "query";

/** input type for updating data in table "table_query_performance" */
export interface TableQueryPerformanceSetInput {
  readonly avg_duration?: InputMaybe<Scalars["interval"]["input"]>;
  readonly capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly execution_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly query?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate stddev on columns */
export interface TableQueryPerformanceStddevFields {
  readonly execution_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface TableQueryPerformanceStddevPopFields {
  readonly execution_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface TableQueryPerformanceStddevSampFields {
  readonly execution_count?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "table_query_performance" */
export interface TableQueryPerformanceStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: TableQueryPerformanceStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface TableQueryPerformanceStreamCursorValueInput {
  readonly avg_duration?: InputMaybe<Scalars["interval"]["input"]>;
  readonly capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly execution_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly query?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface TableQueryPerformanceSumFields {
  readonly execution_count?: Maybe<Scalars["bigint"]["output"]>;
}

/** update columns of table "table_query_performance" */
export type TableQueryPerformanceUpdateColumn =
  /** column name */
  | "avg_duration"
  /** column name */
  | "capture_time"
  /** column name */
  | "execution_count"
  /** column name */
  | "query";

export interface TableQueryPerformanceUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<TableQueryPerformanceIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<TableQueryPerformanceSetInput>;
  /** filter the rows which have to be updated */
  readonly where: TableQueryPerformanceBoolExp;
}

/** aggregate var_pop on columns */
export interface TableQueryPerformanceVarPopFields {
  readonly execution_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface TableQueryPerformanceVarSampFields {
  readonly execution_count?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface TableQueryPerformanceVarianceFields {
  readonly execution_count?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "table_sequence_usage" */
export interface TableSequenceUsage {
  readonly capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly current_value?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_value?: Maybe<Scalars["bigint"]["output"]>;
  readonly sequence_name?: Maybe<Scalars["String"]["output"]>;
}

/** aggregated selection of "table_sequence_usage" */
export interface TableSequenceUsageAggregate {
  readonly aggregate?: Maybe<TableSequenceUsageAggregateFields>;
  readonly nodes: ReadonlyArray<TableSequenceUsage>;
}

/** aggregate fields of "table_sequence_usage" */
export interface TableSequenceUsageAggregateFields {
  readonly avg?: Maybe<TableSequenceUsageAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<TableSequenceUsageMaxFields>;
  readonly min?: Maybe<TableSequenceUsageMinFields>;
  readonly stddev?: Maybe<TableSequenceUsageStddevFields>;
  readonly stddev_pop?: Maybe<TableSequenceUsageStddevPopFields>;
  readonly stddev_samp?: Maybe<TableSequenceUsageStddevSampFields>;
  readonly sum?: Maybe<TableSequenceUsageSumFields>;
  readonly var_pop?: Maybe<TableSequenceUsageVarPopFields>;
  readonly var_samp?: Maybe<TableSequenceUsageVarSampFields>;
  readonly variance?: Maybe<TableSequenceUsageVarianceFields>;
}

/** aggregate fields of "table_sequence_usage" */
export type TableSequenceUsageAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<TableSequenceUsageSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface TableSequenceUsageAvgFields {
  readonly current_value?: Maybe<Scalars["Float"]["output"]>;
  readonly 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 interface TableSequenceUsageBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<TableSequenceUsageBoolExp>>;
  readonly _not?: InputMaybe<TableSequenceUsageBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<TableSequenceUsageBoolExp>>;
  readonly capture_time?: InputMaybe<TimestamptzComparisonExp>;
  readonly current_value?: InputMaybe<BigintComparisonExp>;
  readonly max_value?: InputMaybe<BigintComparisonExp>;
  readonly sequence_name?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "table_sequence_usage" */
export type TableSequenceUsageConstraint =
  /** unique or primary key constraint on columns "capture_time", "sequence_name" */
  "idx_sequence_usage_unique";

/** input type for incrementing numeric columns in table "table_sequence_usage" */
export interface TableSequenceUsageIncInput {
  readonly current_value?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly max_value?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** input type for inserting data into table "table_sequence_usage" */
export interface TableSequenceUsageInsertInput {
  readonly capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly current_value?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly max_value?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly sequence_name?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate max on columns */
export interface TableSequenceUsageMaxFields {
  readonly capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly current_value?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_value?: Maybe<Scalars["bigint"]["output"]>;
  readonly sequence_name?: Maybe<Scalars["String"]["output"]>;
}

/** aggregate min on columns */
export interface TableSequenceUsageMinFields {
  readonly capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly current_value?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_value?: Maybe<Scalars["bigint"]["output"]>;
  readonly sequence_name?: Maybe<Scalars["String"]["output"]>;
}

/** response of any mutation on the table "table_sequence_usage" */
export interface TableSequenceUsageMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<TableSequenceUsage>;
}

/** on_conflict condition type for table "table_sequence_usage" */
export interface TableSequenceUsageOnConflict {
  readonly constraint: TableSequenceUsageConstraint;
  readonly update_columns: ReadonlyArray<TableSequenceUsageUpdateColumn>;
  readonly where?: InputMaybe<TableSequenceUsageBoolExp>;
}

/** Ordering options when selecting data from "table_sequence_usage". */
export interface TableSequenceUsageOrderBy {
  readonly capture_time?: InputMaybe<OrderBy>;
  readonly current_value?: InputMaybe<OrderBy>;
  readonly max_value?: InputMaybe<OrderBy>;
  readonly sequence_name?: InputMaybe<OrderBy>;
}

/** select columns of table "table_sequence_usage" */
export type TableSequenceUsageSelectColumn =
  /** column name */
  | "capture_time"
  /** column name */
  | "current_value"
  /** column name */
  | "max_value"
  /** column name */
  | "sequence_name";

/** input type for updating data in table "table_sequence_usage" */
export interface TableSequenceUsageSetInput {
  readonly capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly current_value?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly max_value?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly sequence_name?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate stddev on columns */
export interface TableSequenceUsageStddevFields {
  readonly current_value?: Maybe<Scalars["Float"]["output"]>;
  readonly max_value?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface TableSequenceUsageStddevPopFields {
  readonly current_value?: Maybe<Scalars["Float"]["output"]>;
  readonly max_value?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface TableSequenceUsageStddevSampFields {
  readonly current_value?: Maybe<Scalars["Float"]["output"]>;
  readonly max_value?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "table_sequence_usage" */
export interface TableSequenceUsageStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: TableSequenceUsageStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface TableSequenceUsageStreamCursorValueInput {
  readonly capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly current_value?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly max_value?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly sequence_name?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface TableSequenceUsageSumFields {
  readonly current_value?: Maybe<Scalars["bigint"]["output"]>;
  readonly max_value?: Maybe<Scalars["bigint"]["output"]>;
}

/** update columns of table "table_sequence_usage" */
export type TableSequenceUsageUpdateColumn =
  /** column name */
  | "capture_time"
  /** column name */
  | "current_value"
  /** column name */
  | "max_value"
  /** column name */
  | "sequence_name";

export interface TableSequenceUsageUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<TableSequenceUsageIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<TableSequenceUsageSetInput>;
  /** filter the rows which have to be updated */
  readonly where: TableSequenceUsageBoolExp;
}

/** aggregate var_pop on columns */
export interface TableSequenceUsageVarPopFields {
  readonly current_value?: Maybe<Scalars["Float"]["output"]>;
  readonly max_value?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface TableSequenceUsageVarSampFields {
  readonly current_value?: Maybe<Scalars["Float"]["output"]>;
  readonly max_value?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface TableSequenceUsageVarianceFields {
  readonly current_value?: Maybe<Scalars["Float"]["output"]>;
  readonly max_value?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "table_statistics" */
export interface TableStatistics {
  readonly buffer_cache_hit_ratio?: Maybe<Scalars["float8"]["output"]>;
  readonly capture_time: Scalars["timestamptz"]["output"];
  readonly dead_tuples?: Maybe<Scalars["bigint"]["output"]>;
  readonly estimated_bloat_ratio?: Maybe<Scalars["float8"]["output"]>;
  readonly index_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly index_size?: Maybe<Scalars["bigint"]["output"]>;
  readonly index_usage?: Maybe<Scalars["jsonb"]["output"]>;
  readonly last_analyze?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly last_vacuum?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly live_tuples?: Maybe<Scalars["bigint"]["output"]>;
  readonly row_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly seq_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly table_name: Scalars["String"]["output"];
  readonly 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 interface TableStatisticsAggregate {
  readonly aggregate?: Maybe<TableStatisticsAggregateFields>;
  readonly nodes: ReadonlyArray<TableStatistics>;
}

/** aggregate fields of "table_statistics" */
export interface TableStatisticsAggregateFields {
  readonly avg?: Maybe<TableStatisticsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<TableStatisticsMaxFields>;
  readonly min?: Maybe<TableStatisticsMinFields>;
  readonly stddev?: Maybe<TableStatisticsStddevFields>;
  readonly stddev_pop?: Maybe<TableStatisticsStddevPopFields>;
  readonly stddev_samp?: Maybe<TableStatisticsStddevSampFields>;
  readonly sum?: Maybe<TableStatisticsSumFields>;
  readonly var_pop?: Maybe<TableStatisticsVarPopFields>;
  readonly var_samp?: Maybe<TableStatisticsVarSampFields>;
  readonly variance?: Maybe<TableStatisticsVarianceFields>;
}

/** aggregate fields of "table_statistics" */
export type TableStatisticsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<TableStatisticsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export interface TableStatisticsAppendInput {
  readonly index_usage?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** aggregate avg on columns */
export interface TableStatisticsAvgFields {
  readonly buffer_cache_hit_ratio?: Maybe<Scalars["Float"]["output"]>;
  readonly dead_tuples?: Maybe<Scalars["Float"]["output"]>;
  readonly estimated_bloat_ratio?: Maybe<Scalars["Float"]["output"]>;
  readonly index_scan_count?: Maybe<Scalars["Float"]["output"]>;
  readonly index_size?: Maybe<Scalars["Float"]["output"]>;
  readonly live_tuples?: Maybe<Scalars["Float"]["output"]>;
  readonly row_count?: Maybe<Scalars["Float"]["output"]>;
  readonly seq_scan_count?: Maybe<Scalars["Float"]["output"]>;
  readonly 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 interface TableStatisticsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<TableStatisticsBoolExp>>;
  readonly _not?: InputMaybe<TableStatisticsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<TableStatisticsBoolExp>>;
  readonly buffer_cache_hit_ratio?: InputMaybe<Float8ComparisonExp>;
  readonly capture_time?: InputMaybe<TimestamptzComparisonExp>;
  readonly dead_tuples?: InputMaybe<BigintComparisonExp>;
  readonly estimated_bloat_ratio?: InputMaybe<Float8ComparisonExp>;
  readonly index_scan_count?: InputMaybe<BigintComparisonExp>;
  readonly index_size?: InputMaybe<BigintComparisonExp>;
  readonly index_usage?: InputMaybe<JsonbComparisonExp>;
  readonly last_analyze?: InputMaybe<TimestamptzComparisonExp>;
  readonly last_vacuum?: InputMaybe<TimestamptzComparisonExp>;
  readonly live_tuples?: InputMaybe<BigintComparisonExp>;
  readonly row_count?: InputMaybe<BigintComparisonExp>;
  readonly seq_scan_count?: InputMaybe<BigintComparisonExp>;
  readonly table_name?: InputMaybe<StringComparisonExp>;
  readonly table_size?: InputMaybe<BigintComparisonExp>;
}

/** unique or primary key constraints on table "table_statistics" */
export type TableStatisticsConstraint =
  /** unique or primary key constraint on columns "capture_time", "table_name" */
  "table_statistics_pkey";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface TableStatisticsDeleteAtPathInput {
  readonly index_usage?: InputMaybe<ReadonlyArray<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 interface TableStatisticsDeleteElemInput {
  readonly index_usage?: InputMaybe<Scalars["Int"]["input"]>;
}

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

/** input type for incrementing numeric columns in table "table_statistics" */
export interface TableStatisticsIncInput {
  readonly buffer_cache_hit_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  readonly dead_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly estimated_bloat_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  readonly index_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly index_size?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly live_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly row_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly seq_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly table_size?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** input type for inserting data into table "table_statistics" */
export interface TableStatisticsInsertInput {
  readonly buffer_cache_hit_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  readonly capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly dead_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly estimated_bloat_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  readonly index_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly index_size?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly index_usage?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly last_analyze?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly last_vacuum?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly live_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly row_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly seq_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly table_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly table_size?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** aggregate max on columns */
export interface TableStatisticsMaxFields {
  readonly buffer_cache_hit_ratio?: Maybe<Scalars["float8"]["output"]>;
  readonly capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly dead_tuples?: Maybe<Scalars["bigint"]["output"]>;
  readonly estimated_bloat_ratio?: Maybe<Scalars["float8"]["output"]>;
  readonly index_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly index_size?: Maybe<Scalars["bigint"]["output"]>;
  readonly last_analyze?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly last_vacuum?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly live_tuples?: Maybe<Scalars["bigint"]["output"]>;
  readonly row_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly seq_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly table_name?: Maybe<Scalars["String"]["output"]>;
  readonly table_size?: Maybe<Scalars["bigint"]["output"]>;
}

/** aggregate min on columns */
export interface TableStatisticsMinFields {
  readonly buffer_cache_hit_ratio?: Maybe<Scalars["float8"]["output"]>;
  readonly capture_time?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly dead_tuples?: Maybe<Scalars["bigint"]["output"]>;
  readonly estimated_bloat_ratio?: Maybe<Scalars["float8"]["output"]>;
  readonly index_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly index_size?: Maybe<Scalars["bigint"]["output"]>;
  readonly last_analyze?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly last_vacuum?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly live_tuples?: Maybe<Scalars["bigint"]["output"]>;
  readonly row_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly seq_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly table_name?: Maybe<Scalars["String"]["output"]>;
  readonly table_size?: Maybe<Scalars["bigint"]["output"]>;
}

/** response of any mutation on the table "table_statistics" */
export interface TableStatisticsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<TableStatistics>;
}

/** on_conflict condition type for table "table_statistics" */
export interface TableStatisticsOnConflict {
  readonly constraint: TableStatisticsConstraint;
  readonly update_columns: ReadonlyArray<TableStatisticsUpdateColumn>;
  readonly where?: InputMaybe<TableStatisticsBoolExp>;
}

/** Ordering options when selecting data from "table_statistics". */
export interface TableStatisticsOrderBy {
  readonly buffer_cache_hit_ratio?: InputMaybe<OrderBy>;
  readonly capture_time?: InputMaybe<OrderBy>;
  readonly dead_tuples?: InputMaybe<OrderBy>;
  readonly estimated_bloat_ratio?: InputMaybe<OrderBy>;
  readonly index_scan_count?: InputMaybe<OrderBy>;
  readonly index_size?: InputMaybe<OrderBy>;
  readonly index_usage?: InputMaybe<OrderBy>;
  readonly last_analyze?: InputMaybe<OrderBy>;
  readonly last_vacuum?: InputMaybe<OrderBy>;
  readonly live_tuples?: InputMaybe<OrderBy>;
  readonly row_count?: InputMaybe<OrderBy>;
  readonly seq_scan_count?: InputMaybe<OrderBy>;
  readonly table_name?: InputMaybe<OrderBy>;
  readonly table_size?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: table_statistics */
export interface TableStatisticsPkColumnsInput {
  readonly capture_time: Scalars["timestamptz"]["input"];
  readonly table_name: Scalars["String"]["input"];
}

/** prepend existing jsonb value of filtered columns with new jsonb value */
export interface TableStatisticsPrependInput {
  readonly index_usage?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** select columns of table "table_statistics" */
export type TableStatisticsSelectColumn =
  /** column name */
  | "buffer_cache_hit_ratio"
  /** column name */
  | "capture_time"
  /** column name */
  | "dead_tuples"
  /** column name */
  | "estimated_bloat_ratio"
  /** column name */
  | "index_scan_count"
  /** column name */
  | "index_size"
  /** column name */
  | "index_usage"
  /** column name */
  | "last_analyze"
  /** column name */
  | "last_vacuum"
  /** column name */
  | "live_tuples"
  /** column name */
  | "row_count"
  /** column name */
  | "seq_scan_count"
  /** column name */
  | "table_name"
  /** column name */
  | "table_size";

/** input type for updating data in table "table_statistics" */
export interface TableStatisticsSetInput {
  readonly buffer_cache_hit_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  readonly capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly dead_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly estimated_bloat_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  readonly index_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly index_size?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly index_usage?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly last_analyze?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly last_vacuum?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly live_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly row_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly seq_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly table_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly table_size?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** aggregate stddev on columns */
export interface TableStatisticsStddevFields {
  readonly buffer_cache_hit_ratio?: Maybe<Scalars["Float"]["output"]>;
  readonly dead_tuples?: Maybe<Scalars["Float"]["output"]>;
  readonly estimated_bloat_ratio?: Maybe<Scalars["Float"]["output"]>;
  readonly index_scan_count?: Maybe<Scalars["Float"]["output"]>;
  readonly index_size?: Maybe<Scalars["Float"]["output"]>;
  readonly live_tuples?: Maybe<Scalars["Float"]["output"]>;
  readonly row_count?: Maybe<Scalars["Float"]["output"]>;
  readonly seq_scan_count?: Maybe<Scalars["Float"]["output"]>;
  readonly table_size?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface TableStatisticsStddevPopFields {
  readonly buffer_cache_hit_ratio?: Maybe<Scalars["Float"]["output"]>;
  readonly dead_tuples?: Maybe<Scalars["Float"]["output"]>;
  readonly estimated_bloat_ratio?: Maybe<Scalars["Float"]["output"]>;
  readonly index_scan_count?: Maybe<Scalars["Float"]["output"]>;
  readonly index_size?: Maybe<Scalars["Float"]["output"]>;
  readonly live_tuples?: Maybe<Scalars["Float"]["output"]>;
  readonly row_count?: Maybe<Scalars["Float"]["output"]>;
  readonly seq_scan_count?: Maybe<Scalars["Float"]["output"]>;
  readonly table_size?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface TableStatisticsStddevSampFields {
  readonly buffer_cache_hit_ratio?: Maybe<Scalars["Float"]["output"]>;
  readonly dead_tuples?: Maybe<Scalars["Float"]["output"]>;
  readonly estimated_bloat_ratio?: Maybe<Scalars["Float"]["output"]>;
  readonly index_scan_count?: Maybe<Scalars["Float"]["output"]>;
  readonly index_size?: Maybe<Scalars["Float"]["output"]>;
  readonly live_tuples?: Maybe<Scalars["Float"]["output"]>;
  readonly row_count?: Maybe<Scalars["Float"]["output"]>;
  readonly seq_scan_count?: Maybe<Scalars["Float"]["output"]>;
  readonly table_size?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "table_statistics" */
export interface TableStatisticsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: TableStatisticsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface TableStatisticsStreamCursorValueInput {
  readonly buffer_cache_hit_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  readonly capture_time?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly dead_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly estimated_bloat_ratio?: InputMaybe<Scalars["float8"]["input"]>;
  readonly index_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly index_size?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly index_usage?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly last_analyze?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly last_vacuum?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly live_tuples?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly row_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly seq_scan_count?: InputMaybe<Scalars["bigint"]["input"]>;
  readonly table_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly table_size?: InputMaybe<Scalars["bigint"]["input"]>;
}

/** aggregate sum on columns */
export interface TableStatisticsSumFields {
  readonly buffer_cache_hit_ratio?: Maybe<Scalars["float8"]["output"]>;
  readonly dead_tuples?: Maybe<Scalars["bigint"]["output"]>;
  readonly estimated_bloat_ratio?: Maybe<Scalars["float8"]["output"]>;
  readonly index_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly index_size?: Maybe<Scalars["bigint"]["output"]>;
  readonly live_tuples?: Maybe<Scalars["bigint"]["output"]>;
  readonly row_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly seq_scan_count?: Maybe<Scalars["bigint"]["output"]>;
  readonly table_size?: Maybe<Scalars["bigint"]["output"]>;
}

/** update columns of table "table_statistics" */
export type TableStatisticsUpdateColumn =
  /** column name */
  | "buffer_cache_hit_ratio"
  /** column name */
  | "capture_time"
  /** column name */
  | "dead_tuples"
  /** column name */
  | "estimated_bloat_ratio"
  /** column name */
  | "index_scan_count"
  /** column name */
  | "index_size"
  /** column name */
  | "index_usage"
  /** column name */
  | "last_analyze"
  /** column name */
  | "last_vacuum"
  /** column name */
  | "live_tuples"
  /** column name */
  | "row_count"
  /** column name */
  | "seq_scan_count"
  /** column name */
  | "table_name"
  /** column name */
  | "table_size";

export interface TableStatisticsUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<TableStatisticsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<TableStatisticsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<TableStatisticsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<TableStatisticsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<TableStatisticsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<TableStatisticsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: TableStatisticsBoolExp;
}

/** aggregate var_pop on columns */
export interface TableStatisticsVarPopFields {
  readonly buffer_cache_hit_ratio?: Maybe<Scalars["Float"]["output"]>;
  readonly dead_tuples?: Maybe<Scalars["Float"]["output"]>;
  readonly estimated_bloat_ratio?: Maybe<Scalars["Float"]["output"]>;
  readonly index_scan_count?: Maybe<Scalars["Float"]["output"]>;
  readonly index_size?: Maybe<Scalars["Float"]["output"]>;
  readonly live_tuples?: Maybe<Scalars["Float"]["output"]>;
  readonly row_count?: Maybe<Scalars["Float"]["output"]>;
  readonly seq_scan_count?: Maybe<Scalars["Float"]["output"]>;
  readonly table_size?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface TableStatisticsVarSampFields {
  readonly buffer_cache_hit_ratio?: Maybe<Scalars["Float"]["output"]>;
  readonly dead_tuples?: Maybe<Scalars["Float"]["output"]>;
  readonly estimated_bloat_ratio?: Maybe<Scalars["Float"]["output"]>;
  readonly index_scan_count?: Maybe<Scalars["Float"]["output"]>;
  readonly index_size?: Maybe<Scalars["Float"]["output"]>;
  readonly live_tuples?: Maybe<Scalars["Float"]["output"]>;
  readonly row_count?: Maybe<Scalars["Float"]["output"]>;
  readonly seq_scan_count?: Maybe<Scalars["Float"]["output"]>;
  readonly table_size?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface TableStatisticsVarianceFields {
  readonly buffer_cache_hit_ratio?: Maybe<Scalars["Float"]["output"]>;
  readonly dead_tuples?: Maybe<Scalars["Float"]["output"]>;
  readonly estimated_bloat_ratio?: Maybe<Scalars["Float"]["output"]>;
  readonly index_scan_count?: Maybe<Scalars["Float"]["output"]>;
  readonly index_size?: Maybe<Scalars["Float"]["output"]>;
  readonly live_tuples?: Maybe<Scalars["Float"]["output"]>;
  readonly row_count?: Maybe<Scalars["Float"]["output"]>;
  readonly seq_scan_count?: Maybe<Scalars["Float"]["output"]>;
  readonly table_size?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "tags" */
export interface Tags {
  readonly body?: Maybe<Scalars["String"]["output"]>;
  /** An array relationship */
  readonly content_tags: ReadonlyArray<ContentTags>;
  /** An aggregate relationship */
  readonly content_tags_aggregate: ContentTagsAggregate;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly document_id?: Maybe<Scalars["String"]["output"]>;
  readonly id: Scalars["Int"]["output"];
  readonly locale?: Maybe<Scalars["String"]["output"]>;
  readonly name: Scalars["String"]["output"];
  /** An array relationship */
  readonly news_tags: ReadonlyArray<NewsTags>;
  /** An aggregate relationship */
  readonly news_tags_aggregate: NewsTagsAggregate;
  readonly published_at?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** columns and relationships of "tags" */
export type TagsContentTagsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentTagsOrderBy>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

/** columns and relationships of "tags" */
export type TagsContentTagsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentTagsOrderBy>>;
  where?: InputMaybe<ContentTagsBoolExp>;
};

/** columns and relationships of "tags" */
export type TagsNewsTagsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsTagsOrderBy>>;
  where?: InputMaybe<NewsTagsBoolExp>;
};

/** columns and relationships of "tags" */
export type TagsNewsTagsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<NewsTagsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsTagsOrderBy>>;
  where?: InputMaybe<NewsTagsBoolExp>;
};

/** aggregated selection of "tags" */
export interface TagsAggregate {
  readonly aggregate?: Maybe<TagsAggregateFields>;
  readonly nodes: ReadonlyArray<Tags>;
}

/** aggregate fields of "tags" */
export interface TagsAggregateFields {
  readonly avg?: Maybe<TagsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<TagsMaxFields>;
  readonly min?: Maybe<TagsMinFields>;
  readonly stddev?: Maybe<TagsStddevFields>;
  readonly stddev_pop?: Maybe<TagsStddevPopFields>;
  readonly stddev_samp?: Maybe<TagsStddevSampFields>;
  readonly sum?: Maybe<TagsSumFields>;
  readonly var_pop?: Maybe<TagsVarPopFields>;
  readonly var_samp?: Maybe<TagsVarSampFields>;
  readonly variance?: Maybe<TagsVarianceFields>;
}

/** aggregate fields of "tags" */
export type TagsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<TagsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface TagsAvgFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "tags". All fields are combined with a logical 'AND'. */
export interface TagsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<TagsBoolExp>>;
  readonly _not?: InputMaybe<TagsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<TagsBoolExp>>;
  readonly body?: InputMaybe<StringComparisonExp>;
  readonly content_tags?: InputMaybe<ContentTagsBoolExp>;
  readonly content_tags_aggregate?: InputMaybe<ContentTagsAggregateBoolExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly document_id?: InputMaybe<StringComparisonExp>;
  readonly id?: InputMaybe<IntComparisonExp>;
  readonly locale?: InputMaybe<StringComparisonExp>;
  readonly name?: InputMaybe<StringComparisonExp>;
  readonly news_tags?: InputMaybe<NewsTagsBoolExp>;
  readonly news_tags_aggregate?: InputMaybe<NewsTagsAggregateBoolExp>;
  readonly published_at?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
}

/** unique or primary key constraints on table "tags" */
export type TagsConstraint =
  /** unique or primary key constraint on columns "name" */
  | "tags_name_key"
  /** unique or primary key constraint on columns "id" */
  | "tags_pkey";

/** input type for incrementing numeric columns in table "tags" */
export interface TagsIncInput {
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "tags" */
export interface TagsInsertInput {
  readonly body?: InputMaybe<Scalars["String"]["input"]>;
  readonly content_tags?: InputMaybe<ContentTagsArrRelInsertInput>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly document_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly locale?: InputMaybe<Scalars["String"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly news_tags?: InputMaybe<NewsTagsArrRelInsertInput>;
  readonly published_at?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate max on columns */
export interface TagsMaxFields {
  readonly body?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly document_id?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly locale?: Maybe<Scalars["String"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly published_at?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** aggregate min on columns */
export interface TagsMinFields {
  readonly body?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly document_id?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["Int"]["output"]>;
  readonly locale?: Maybe<Scalars["String"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly published_at?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** response of any mutation on the table "tags" */
export interface TagsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Tags>;
}

/** input type for inserting object relation for remote table "tags" */
export interface TagsObjRelInsertInput {
  readonly data: TagsInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<TagsOnConflict>;
}

/** on_conflict condition type for table "tags" */
export interface TagsOnConflict {
  readonly constraint: TagsConstraint;
  readonly update_columns: ReadonlyArray<TagsUpdateColumn>;
  readonly where?: InputMaybe<TagsBoolExp>;
}

/** Ordering options when selecting data from "tags". */
export interface TagsOrderBy {
  readonly body?: InputMaybe<OrderBy>;
  readonly content_tags_aggregate?: InputMaybe<ContentTagsAggregateOrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly document_id?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly locale?: InputMaybe<OrderBy>;
  readonly name?: InputMaybe<OrderBy>;
  readonly news_tags_aggregate?: InputMaybe<NewsTagsAggregateOrderBy>;
  readonly published_at?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: tags */
export interface TagsPkColumnsInput {
  readonly id: Scalars["Int"]["input"];
}

/** select columns of table "tags" */
export type TagsSelectColumn =
  /** column name */
  | "body"
  /** column name */
  | "created_at"
  /** column name */
  | "document_id"
  /** column name */
  | "id"
  /** column name */
  | "locale"
  /** column name */
  | "name"
  /** column name */
  | "published_at"
  /** column name */
  | "updated_at";

/** input type for updating data in table "tags" */
export interface TagsSetInput {
  readonly body?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly document_id?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["Int"]["input"]>;
  readonly locale?: InputMaybe<Scalars["String"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly published_at?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate stddev on columns */
export interface TagsStddevFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface TagsStddevPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface TagsStddevSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "tags" */
export interface TagsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: TagsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

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

/** aggregate sum on columns */
export interface TagsSumFields {
  readonly id?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "tags" */
export type TagsUpdateColumn =
  /** column name */
  | "body"
  /** column name */
  | "created_at"
  /** column name */
  | "document_id"
  /** column name */
  | "id"
  /** column name */
  | "locale"
  /** column name */
  | "name"
  /** column name */
  | "published_at"
  /** column name */
  | "updated_at";

export interface TagsUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<TagsIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<TagsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: TagsBoolExp;
}

/** aggregate var_pop on columns */
export interface TagsVarPopFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface TagsVarSampFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface TagsVarianceFields {
  readonly id?: Maybe<Scalars["Float"]["output"]>;
}

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

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

/** columns and relationships of "user_metrics" */
export interface UserMetrics {
  readonly achievements?: Maybe<Scalars["jsonb"]["output"]>;
  readonly best_streak?: Maybe<Scalars["Int"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly current_level?: Maybe<Scalars["Int"]["output"]>;
  readonly current_streak?: Maybe<Scalars["Int"]["output"]>;
  readonly current_xp?: Maybe<Scalars["Int"]["output"]>;
  readonly downvote_count?: Maybe<Scalars["Int"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  readonly interaction_stats?: Maybe<Scalars["jsonb"]["output"]>;
  readonly last_vote_date?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly multipliers?: Maybe<Scalars["jsonb"]["output"]>;
  readonly points?: Maybe<Scalars["Int"]["output"]>;
  readonly points_breakdown?: Maybe<Scalars["jsonb"]["output"]>;
  readonly titles?: Maybe<Scalars["jsonb"]["output"]>;
  readonly today_vote_count?: Maybe<Scalars["Int"]["output"]>;
  readonly total_reading_time?: Maybe<Scalars["Int"]["output"]>;
  readonly total_votes?: Maybe<Scalars["Int"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly upvote_count?: Maybe<Scalars["Int"]["output"]>;
  readonly user_id: Scalars["uuid"]["output"];
  /** An object relationship */
  readonly user_profile: UserProfiles;
  readonly vote_accuracy?: Maybe<Scalars["numeric"]["output"]>;
  readonly 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 interface UserMetricsAggregate {
  readonly aggregate?: Maybe<UserMetricsAggregateFields>;
  readonly nodes: ReadonlyArray<UserMetrics>;
}

/** aggregate fields of "user_metrics" */
export interface UserMetricsAggregateFields {
  readonly avg?: Maybe<UserMetricsAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<UserMetricsMaxFields>;
  readonly min?: Maybe<UserMetricsMinFields>;
  readonly stddev?: Maybe<UserMetricsStddevFields>;
  readonly stddev_pop?: Maybe<UserMetricsStddevPopFields>;
  readonly stddev_samp?: Maybe<UserMetricsStddevSampFields>;
  readonly sum?: Maybe<UserMetricsSumFields>;
  readonly var_pop?: Maybe<UserMetricsVarPopFields>;
  readonly var_samp?: Maybe<UserMetricsVarSampFields>;
  readonly variance?: Maybe<UserMetricsVarianceFields>;
}

/** aggregate fields of "user_metrics" */
export type UserMetricsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<UserMetricsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** append existing jsonb value of filtered columns with new jsonb value */
export interface UserMetricsAppendInput {
  readonly achievements?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly interaction_stats?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly multipliers?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly points_breakdown?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly titles?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** aggregate avg on columns */
export interface UserMetricsAvgFields {
  readonly best_streak?: Maybe<Scalars["Float"]["output"]>;
  readonly current_level?: Maybe<Scalars["Float"]["output"]>;
  readonly current_streak?: Maybe<Scalars["Float"]["output"]>;
  readonly current_xp?: Maybe<Scalars["Float"]["output"]>;
  readonly downvote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly points?: Maybe<Scalars["Float"]["output"]>;
  readonly today_vote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly total_reading_time?: Maybe<Scalars["Float"]["output"]>;
  readonly total_votes?: Maybe<Scalars["Float"]["output"]>;
  readonly upvote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly vote_accuracy?: Maybe<Scalars["Float"]["output"]>;
  readonly 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 interface UserMetricsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<UserMetricsBoolExp>>;
  readonly _not?: InputMaybe<UserMetricsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<UserMetricsBoolExp>>;
  readonly achievements?: InputMaybe<JsonbComparisonExp>;
  readonly best_streak?: InputMaybe<IntComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly current_level?: InputMaybe<IntComparisonExp>;
  readonly current_streak?: InputMaybe<IntComparisonExp>;
  readonly current_xp?: InputMaybe<IntComparisonExp>;
  readonly downvote_count?: InputMaybe<IntComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly interaction_stats?: InputMaybe<JsonbComparisonExp>;
  readonly last_vote_date?: InputMaybe<TimestamptzComparisonExp>;
  readonly multipliers?: InputMaybe<JsonbComparisonExp>;
  readonly points?: InputMaybe<IntComparisonExp>;
  readonly points_breakdown?: InputMaybe<JsonbComparisonExp>;
  readonly titles?: InputMaybe<JsonbComparisonExp>;
  readonly today_vote_count?: InputMaybe<IntComparisonExp>;
  readonly total_reading_time?: InputMaybe<IntComparisonExp>;
  readonly total_votes?: InputMaybe<IntComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly upvote_count?: InputMaybe<IntComparisonExp>;
  readonly user_id?: InputMaybe<UuidComparisonExp>;
  readonly user_profile?: InputMaybe<UserProfilesBoolExp>;
  readonly vote_accuracy?: InputMaybe<NumericComparisonExp>;
  readonly xp_to_next_level?: InputMaybe<IntComparisonExp>;
}

/** unique or primary key constraints on table "user_metrics" */
export type UserMetricsConstraint =
  /** unique or primary key constraint on columns "id" */
  | "user_metrics_pkey"
  /** unique or primary key constraint on columns "user_id" */
  | "user_metrics_user_id_key";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface UserMetricsDeleteAtPathInput {
  readonly achievements?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
  readonly interaction_stats?: InputMaybe<
    ReadonlyArray<Scalars["String"]["input"]>
  >;
  readonly multipliers?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
  readonly points_breakdown?: InputMaybe<
    ReadonlyArray<Scalars["String"]["input"]>
  >;
  readonly titles?: InputMaybe<ReadonlyArray<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 interface UserMetricsDeleteElemInput {
  readonly achievements?: InputMaybe<Scalars["Int"]["input"]>;
  readonly interaction_stats?: InputMaybe<Scalars["Int"]["input"]>;
  readonly multipliers?: InputMaybe<Scalars["Int"]["input"]>;
  readonly points_breakdown?: InputMaybe<Scalars["Int"]["input"]>;
  readonly titles?: InputMaybe<Scalars["Int"]["input"]>;
}

/** delete key/value pair or string element. key/value pairs are matched based on their key value */
export interface UserMetricsDeleteKeyInput {
  readonly achievements?: InputMaybe<Scalars["String"]["input"]>;
  readonly interaction_stats?: InputMaybe<Scalars["String"]["input"]>;
  readonly multipliers?: InputMaybe<Scalars["String"]["input"]>;
  readonly points_breakdown?: InputMaybe<Scalars["String"]["input"]>;
  readonly titles?: InputMaybe<Scalars["String"]["input"]>;
}

/** input type for incrementing numeric columns in table "user_metrics" */
export interface UserMetricsIncInput {
  readonly best_streak?: InputMaybe<Scalars["Int"]["input"]>;
  readonly current_level?: InputMaybe<Scalars["Int"]["input"]>;
  readonly current_streak?: InputMaybe<Scalars["Int"]["input"]>;
  readonly current_xp?: InputMaybe<Scalars["Int"]["input"]>;
  readonly downvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly points?: InputMaybe<Scalars["Int"]["input"]>;
  readonly today_vote_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly total_reading_time?: InputMaybe<Scalars["Int"]["input"]>;
  readonly total_votes?: InputMaybe<Scalars["Int"]["input"]>;
  readonly upvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly vote_accuracy?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly xp_to_next_level?: InputMaybe<Scalars["Int"]["input"]>;
}

/** input type for inserting data into table "user_metrics" */
export interface UserMetricsInsertInput {
  readonly achievements?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly best_streak?: InputMaybe<Scalars["Int"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly current_level?: InputMaybe<Scalars["Int"]["input"]>;
  readonly current_streak?: InputMaybe<Scalars["Int"]["input"]>;
  readonly current_xp?: InputMaybe<Scalars["Int"]["input"]>;
  readonly downvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly interaction_stats?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly last_vote_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly multipliers?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly points?: InputMaybe<Scalars["Int"]["input"]>;
  readonly points_breakdown?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly titles?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly today_vote_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly total_reading_time?: InputMaybe<Scalars["Int"]["input"]>;
  readonly total_votes?: InputMaybe<Scalars["Int"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly upvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_profile?: InputMaybe<UserProfilesObjRelInsertInput>;
  readonly vote_accuracy?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly xp_to_next_level?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate max on columns */
export interface UserMetricsMaxFields {
  readonly best_streak?: Maybe<Scalars["Int"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly current_level?: Maybe<Scalars["Int"]["output"]>;
  readonly current_streak?: Maybe<Scalars["Int"]["output"]>;
  readonly current_xp?: Maybe<Scalars["Int"]["output"]>;
  readonly downvote_count?: Maybe<Scalars["Int"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly last_vote_date?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly points?: Maybe<Scalars["Int"]["output"]>;
  readonly today_vote_count?: Maybe<Scalars["Int"]["output"]>;
  readonly total_reading_time?: Maybe<Scalars["Int"]["output"]>;
  readonly total_votes?: Maybe<Scalars["Int"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly upvote_count?: Maybe<Scalars["Int"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly vote_accuracy?: Maybe<Scalars["numeric"]["output"]>;
  readonly xp_to_next_level?: Maybe<Scalars["Int"]["output"]>;
}

/** aggregate min on columns */
export interface UserMetricsMinFields {
  readonly best_streak?: Maybe<Scalars["Int"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly current_level?: Maybe<Scalars["Int"]["output"]>;
  readonly current_streak?: Maybe<Scalars["Int"]["output"]>;
  readonly current_xp?: Maybe<Scalars["Int"]["output"]>;
  readonly downvote_count?: Maybe<Scalars["Int"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly last_vote_date?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly points?: Maybe<Scalars["Int"]["output"]>;
  readonly today_vote_count?: Maybe<Scalars["Int"]["output"]>;
  readonly total_reading_time?: Maybe<Scalars["Int"]["output"]>;
  readonly total_votes?: Maybe<Scalars["Int"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly upvote_count?: Maybe<Scalars["Int"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly vote_accuracy?: Maybe<Scalars["numeric"]["output"]>;
  readonly xp_to_next_level?: Maybe<Scalars["Int"]["output"]>;
}

/** response of any mutation on the table "user_metrics" */
export interface UserMetricsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<UserMetrics>;
}

/** input type for inserting object relation for remote table "user_metrics" */
export interface UserMetricsObjRelInsertInput {
  readonly data: UserMetricsInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<UserMetricsOnConflict>;
}

/** on_conflict condition type for table "user_metrics" */
export interface UserMetricsOnConflict {
  readonly constraint: UserMetricsConstraint;
  readonly update_columns: ReadonlyArray<UserMetricsUpdateColumn>;
  readonly where?: InputMaybe<UserMetricsBoolExp>;
}

/** Ordering options when selecting data from "user_metrics". */
export interface UserMetricsOrderBy {
  readonly achievements?: InputMaybe<OrderBy>;
  readonly best_streak?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly current_level?: InputMaybe<OrderBy>;
  readonly current_streak?: InputMaybe<OrderBy>;
  readonly current_xp?: InputMaybe<OrderBy>;
  readonly downvote_count?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly interaction_stats?: InputMaybe<OrderBy>;
  readonly last_vote_date?: InputMaybe<OrderBy>;
  readonly multipliers?: InputMaybe<OrderBy>;
  readonly points?: InputMaybe<OrderBy>;
  readonly points_breakdown?: InputMaybe<OrderBy>;
  readonly titles?: InputMaybe<OrderBy>;
  readonly today_vote_count?: InputMaybe<OrderBy>;
  readonly total_reading_time?: InputMaybe<OrderBy>;
  readonly total_votes?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly upvote_count?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
  readonly user_profile?: InputMaybe<UserProfilesOrderBy>;
  readonly vote_accuracy?: InputMaybe<OrderBy>;
  readonly xp_to_next_level?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: user_metrics */
export interface UserMetricsPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** prepend existing jsonb value of filtered columns with new jsonb value */
export interface UserMetricsPrependInput {
  readonly achievements?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly interaction_stats?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly multipliers?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly points_breakdown?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly titles?: InputMaybe<Scalars["jsonb"]["input"]>;
}

/** select columns of table "user_metrics" */
export type UserMetricsSelectColumn =
  /** column name */
  | "achievements"
  /** column name */
  | "best_streak"
  /** column name */
  | "created_at"
  /** column name */
  | "current_level"
  /** column name */
  | "current_streak"
  /** column name */
  | "current_xp"
  /** column name */
  | "downvote_count"
  /** column name */
  | "id"
  /** column name */
  | "interaction_stats"
  /** column name */
  | "last_vote_date"
  /** column name */
  | "multipliers"
  /** column name */
  | "points"
  /** column name */
  | "points_breakdown"
  /** column name */
  | "titles"
  /** column name */
  | "today_vote_count"
  /** column name */
  | "total_reading_time"
  /** column name */
  | "total_votes"
  /** column name */
  | "updated_at"
  /** column name */
  | "upvote_count"
  /** column name */
  | "user_id"
  /** column name */
  | "vote_accuracy"
  /** column name */
  | "xp_to_next_level";

/** input type for updating data in table "user_metrics" */
export interface UserMetricsSetInput {
  readonly achievements?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly best_streak?: InputMaybe<Scalars["Int"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly current_level?: InputMaybe<Scalars["Int"]["input"]>;
  readonly current_streak?: InputMaybe<Scalars["Int"]["input"]>;
  readonly current_xp?: InputMaybe<Scalars["Int"]["input"]>;
  readonly downvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly interaction_stats?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly last_vote_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly multipliers?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly points?: InputMaybe<Scalars["Int"]["input"]>;
  readonly points_breakdown?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly titles?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly today_vote_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly total_reading_time?: InputMaybe<Scalars["Int"]["input"]>;
  readonly total_votes?: InputMaybe<Scalars["Int"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly upvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly vote_accuracy?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly xp_to_next_level?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate stddev on columns */
export interface UserMetricsStddevFields {
  readonly best_streak?: Maybe<Scalars["Float"]["output"]>;
  readonly current_level?: Maybe<Scalars["Float"]["output"]>;
  readonly current_streak?: Maybe<Scalars["Float"]["output"]>;
  readonly current_xp?: Maybe<Scalars["Float"]["output"]>;
  readonly downvote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly points?: Maybe<Scalars["Float"]["output"]>;
  readonly today_vote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly total_reading_time?: Maybe<Scalars["Float"]["output"]>;
  readonly total_votes?: Maybe<Scalars["Float"]["output"]>;
  readonly upvote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly vote_accuracy?: Maybe<Scalars["Float"]["output"]>;
  readonly xp_to_next_level?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface UserMetricsStddevPopFields {
  readonly best_streak?: Maybe<Scalars["Float"]["output"]>;
  readonly current_level?: Maybe<Scalars["Float"]["output"]>;
  readonly current_streak?: Maybe<Scalars["Float"]["output"]>;
  readonly current_xp?: Maybe<Scalars["Float"]["output"]>;
  readonly downvote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly points?: Maybe<Scalars["Float"]["output"]>;
  readonly today_vote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly total_reading_time?: Maybe<Scalars["Float"]["output"]>;
  readonly total_votes?: Maybe<Scalars["Float"]["output"]>;
  readonly upvote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly vote_accuracy?: Maybe<Scalars["Float"]["output"]>;
  readonly xp_to_next_level?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface UserMetricsStddevSampFields {
  readonly best_streak?: Maybe<Scalars["Float"]["output"]>;
  readonly current_level?: Maybe<Scalars["Float"]["output"]>;
  readonly current_streak?: Maybe<Scalars["Float"]["output"]>;
  readonly current_xp?: Maybe<Scalars["Float"]["output"]>;
  readonly downvote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly points?: Maybe<Scalars["Float"]["output"]>;
  readonly today_vote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly total_reading_time?: Maybe<Scalars["Float"]["output"]>;
  readonly total_votes?: Maybe<Scalars["Float"]["output"]>;
  readonly upvote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly vote_accuracy?: Maybe<Scalars["Float"]["output"]>;
  readonly xp_to_next_level?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "user_metrics" */
export interface UserMetricsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: UserMetricsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface UserMetricsStreamCursorValueInput {
  readonly achievements?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly best_streak?: InputMaybe<Scalars["Int"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly current_level?: InputMaybe<Scalars["Int"]["input"]>;
  readonly current_streak?: InputMaybe<Scalars["Int"]["input"]>;
  readonly current_xp?: InputMaybe<Scalars["Int"]["input"]>;
  readonly downvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly interaction_stats?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly last_vote_date?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly multipliers?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly points?: InputMaybe<Scalars["Int"]["input"]>;
  readonly points_breakdown?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly titles?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly today_vote_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly total_reading_time?: InputMaybe<Scalars["Int"]["input"]>;
  readonly total_votes?: InputMaybe<Scalars["Int"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly upvote_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly vote_accuracy?: InputMaybe<Scalars["numeric"]["input"]>;
  readonly xp_to_next_level?: InputMaybe<Scalars["Int"]["input"]>;
}

/** aggregate sum on columns */
export interface UserMetricsSumFields {
  readonly best_streak?: Maybe<Scalars["Int"]["output"]>;
  readonly current_level?: Maybe<Scalars["Int"]["output"]>;
  readonly current_streak?: Maybe<Scalars["Int"]["output"]>;
  readonly current_xp?: Maybe<Scalars["Int"]["output"]>;
  readonly downvote_count?: Maybe<Scalars["Int"]["output"]>;
  readonly points?: Maybe<Scalars["Int"]["output"]>;
  readonly today_vote_count?: Maybe<Scalars["Int"]["output"]>;
  readonly total_reading_time?: Maybe<Scalars["Int"]["output"]>;
  readonly total_votes?: Maybe<Scalars["Int"]["output"]>;
  readonly upvote_count?: Maybe<Scalars["Int"]["output"]>;
  readonly vote_accuracy?: Maybe<Scalars["numeric"]["output"]>;
  readonly xp_to_next_level?: Maybe<Scalars["Int"]["output"]>;
}

/** update columns of table "user_metrics" */
export type UserMetricsUpdateColumn =
  /** column name */
  | "achievements"
  /** column name */
  | "best_streak"
  /** column name */
  | "created_at"
  /** column name */
  | "current_level"
  /** column name */
  | "current_streak"
  /** column name */
  | "current_xp"
  /** column name */
  | "downvote_count"
  /** column name */
  | "id"
  /** column name */
  | "interaction_stats"
  /** column name */
  | "last_vote_date"
  /** column name */
  | "multipliers"
  /** column name */
  | "points"
  /** column name */
  | "points_breakdown"
  /** column name */
  | "titles"
  /** column name */
  | "today_vote_count"
  /** column name */
  | "total_reading_time"
  /** column name */
  | "total_votes"
  /** column name */
  | "updated_at"
  /** column name */
  | "upvote_count"
  /** column name */
  | "user_id"
  /** column name */
  | "vote_accuracy"
  /** column name */
  | "xp_to_next_level";

export interface UserMetricsUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<UserMetricsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<UserMetricsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<UserMetricsDeleteKeyInput>;
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<UserMetricsIncInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<UserMetricsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<UserMetricsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: UserMetricsBoolExp;
}

/** aggregate var_pop on columns */
export interface UserMetricsVarPopFields {
  readonly best_streak?: Maybe<Scalars["Float"]["output"]>;
  readonly current_level?: Maybe<Scalars["Float"]["output"]>;
  readonly current_streak?: Maybe<Scalars["Float"]["output"]>;
  readonly current_xp?: Maybe<Scalars["Float"]["output"]>;
  readonly downvote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly points?: Maybe<Scalars["Float"]["output"]>;
  readonly today_vote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly total_reading_time?: Maybe<Scalars["Float"]["output"]>;
  readonly total_votes?: Maybe<Scalars["Float"]["output"]>;
  readonly upvote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly vote_accuracy?: Maybe<Scalars["Float"]["output"]>;
  readonly xp_to_next_level?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface UserMetricsVarSampFields {
  readonly best_streak?: Maybe<Scalars["Float"]["output"]>;
  readonly current_level?: Maybe<Scalars["Float"]["output"]>;
  readonly current_streak?: Maybe<Scalars["Float"]["output"]>;
  readonly current_xp?: Maybe<Scalars["Float"]["output"]>;
  readonly downvote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly points?: Maybe<Scalars["Float"]["output"]>;
  readonly today_vote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly total_reading_time?: Maybe<Scalars["Float"]["output"]>;
  readonly total_votes?: Maybe<Scalars["Float"]["output"]>;
  readonly upvote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly vote_accuracy?: Maybe<Scalars["Float"]["output"]>;
  readonly xp_to_next_level?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface UserMetricsVarianceFields {
  readonly best_streak?: Maybe<Scalars["Float"]["output"]>;
  readonly current_level?: Maybe<Scalars["Float"]["output"]>;
  readonly current_streak?: Maybe<Scalars["Float"]["output"]>;
  readonly current_xp?: Maybe<Scalars["Float"]["output"]>;
  readonly downvote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly points?: Maybe<Scalars["Float"]["output"]>;
  readonly today_vote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly total_reading_time?: Maybe<Scalars["Float"]["output"]>;
  readonly total_votes?: Maybe<Scalars["Float"]["output"]>;
  readonly upvote_count?: Maybe<Scalars["Float"]["output"]>;
  readonly vote_accuracy?: Maybe<Scalars["Float"]["output"]>;
  readonly xp_to_next_level?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "user_profiles" */
export interface UserProfiles {
  /** An array relationship */
  readonly addresses: ReadonlyArray<Addresses>;
  /** An aggregate relationship */
  readonly addresses_aggregate: AddressesAggregate;
  readonly avatar?: Maybe<Scalars["String"]["output"]>;
  /** An array relationship */
  readonly comments: ReadonlyArray<Comments>;
  /** An aggregate relationship */
  readonly comments_aggregate: CommentsAggregate;
  /** An array relationship */
  readonly company_employees: ReadonlyArray<CompanyEmployees>;
  /** An aggregate relationship */
  readonly company_employees_aggregate: CompanyEmployeesAggregate;
  /** An array relationship */
  readonly contacts: ReadonlyArray<Contacts>;
  /** An aggregate relationship */
  readonly contacts_aggregate: ContactsAggregate;
  /** An array relationship */
  readonly content_source_visits: ReadonlyArray<ContentSourceVisits>;
  /** An aggregate relationship */
  readonly content_source_visits_aggregate: ContentSourceVisitsAggregate;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  /** An array relationship */
  readonly customer_payments: ReadonlyArray<CustomerPayments>;
  /** An aggregate relationship */
  readonly customer_payments_aggregate: CustomerPaymentsAggregate;
  /** An array relationship */
  readonly customer_subscriptions: ReadonlyArray<CustomerSubscriptions>;
  /** An aggregate relationship */
  readonly customer_subscriptions_aggregate: CustomerSubscriptionsAggregate;
  readonly dob?: Maybe<Scalars["date"]["output"]>;
  readonly email: Scalars["String"]["output"];
  /** An array relationship */
  readonly feedbacks: ReadonlyArray<Feedbacks>;
  /** An aggregate relationship */
  readonly feedbacks_aggregate: FeedbacksAggregate;
  /** An array relationship */
  readonly feeds: ReadonlyArray<Feeds>;
  /** An aggregate relationship */
  readonly feeds_aggregate: FeedsAggregate;
  readonly followed_count?: Maybe<Scalars["Int"]["output"]>;
  readonly followers_count?: Maybe<Scalars["Int"]["output"]>;
  /** An array relationship */
  readonly follows: ReadonlyArray<Follows>;
  /** An aggregate relationship */
  readonly follows_aggregate: FollowsAggregate;
  readonly gender_id?: Maybe<Scalars["smallint"]["output"]>;
  readonly given_name?: Maybe<Scalars["String"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  readonly introduction?: Maybe<Scalars["String"]["output"]>;
  readonly is_active?: Maybe<Scalars["Boolean"]["output"]>;
  readonly last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly plan?: Maybe<Scalars["app_plan_enum"]["output"]>;
  readonly role: Scalars["app_role_enum"]["output"];
  readonly surname?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  /** An object relationship */
  readonly user_metric?: Maybe<UserMetrics>;
  readonly username?: Maybe<Scalars["String"]["output"]>;
}

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

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

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

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

/** columns and relationships of "user_profiles" */
export type UserProfilesCompanyEmployeesArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyEmployeesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyEmployeesOrderBy>>;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesCompanyEmployeesAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CompanyEmployeesSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompanyEmployeesOrderBy>>;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
};

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

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

/** columns and relationships of "user_profiles" */
export type UserProfilesContentSourceVisitsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesContentSourceVisitsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<ContentSourceVisitsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentSourceVisitsOrderBy>>;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesCustomerPaymentsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesCustomerPaymentsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerPaymentsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerPaymentsOrderBy>>;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesCustomerSubscriptionsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesCustomerSubscriptionsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<CustomerSubscriptionsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CustomerSubscriptionsOrderBy>>;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesFeedbacksArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedbacksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedbacksOrderBy>>;
  where?: InputMaybe<FeedbacksBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesFeedbacksAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedbacksSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedbacksOrderBy>>;
  where?: InputMaybe<FeedbacksBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesFeedsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedsOrderBy>>;
  where?: InputMaybe<FeedsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesFeedsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FeedsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedsOrderBy>>;
  where?: InputMaybe<FeedsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesFollowsArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FollowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FollowsOrderBy>>;
  where?: InputMaybe<FollowsBoolExp>;
};

/** columns and relationships of "user_profiles" */
export type UserProfilesFollowsAggregateArgs = {
  distinct_on?: InputMaybe<ReadonlyArray<FollowsSelectColumn>>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FollowsOrderBy>>;
  where?: InputMaybe<FollowsBoolExp>;
};

/** aggregated selection of "user_profiles" */
export interface UserProfilesAggregate {
  readonly aggregate?: Maybe<UserProfilesAggregateFields>;
  readonly nodes: ReadonlyArray<UserProfiles>;
}

/** aggregate fields of "user_profiles" */
export interface UserProfilesAggregateFields {
  readonly avg?: Maybe<UserProfilesAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<UserProfilesMaxFields>;
  readonly min?: Maybe<UserProfilesMinFields>;
  readonly stddev?: Maybe<UserProfilesStddevFields>;
  readonly stddev_pop?: Maybe<UserProfilesStddevPopFields>;
  readonly stddev_samp?: Maybe<UserProfilesStddevSampFields>;
  readonly sum?: Maybe<UserProfilesSumFields>;
  readonly var_pop?: Maybe<UserProfilesVarPopFields>;
  readonly var_samp?: Maybe<UserProfilesVarSampFields>;
  readonly variance?: Maybe<UserProfilesVarianceFields>;
}

/** aggregate fields of "user_profiles" */
export type UserProfilesAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<UserProfilesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface UserProfilesAvgFields {
  readonly followed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly followers_count?: Maybe<Scalars["Float"]["output"]>;
  readonly 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 interface UserProfilesBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<UserProfilesBoolExp>>;
  readonly _not?: InputMaybe<UserProfilesBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<UserProfilesBoolExp>>;
  readonly addresses?: InputMaybe<AddressesBoolExp>;
  readonly addresses_aggregate?: InputMaybe<AddressesAggregateBoolExp>;
  readonly avatar?: InputMaybe<StringComparisonExp>;
  readonly comments?: InputMaybe<CommentsBoolExp>;
  readonly comments_aggregate?: InputMaybe<CommentsAggregateBoolExp>;
  readonly company_employees?: InputMaybe<CompanyEmployeesBoolExp>;
  readonly company_employees_aggregate?: InputMaybe<CompanyEmployeesAggregateBoolExp>;
  readonly contacts?: InputMaybe<ContactsBoolExp>;
  readonly contacts_aggregate?: InputMaybe<ContactsAggregateBoolExp>;
  readonly content_source_visits?: InputMaybe<ContentSourceVisitsBoolExp>;
  readonly content_source_visits_aggregate?: InputMaybe<ContentSourceVisitsAggregateBoolExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly customer_payments?: InputMaybe<CustomerPaymentsBoolExp>;
  readonly customer_payments_aggregate?: InputMaybe<CustomerPaymentsAggregateBoolExp>;
  readonly customer_subscriptions?: InputMaybe<CustomerSubscriptionsBoolExp>;
  readonly customer_subscriptions_aggregate?: InputMaybe<CustomerSubscriptionsAggregateBoolExp>;
  readonly dob?: InputMaybe<DateComparisonExp>;
  readonly email?: InputMaybe<StringComparisonExp>;
  readonly feedbacks?: InputMaybe<FeedbacksBoolExp>;
  readonly feedbacks_aggregate?: InputMaybe<FeedbacksAggregateBoolExp>;
  readonly feeds?: InputMaybe<FeedsBoolExp>;
  readonly feeds_aggregate?: InputMaybe<FeedsAggregateBoolExp>;
  readonly followed_count?: InputMaybe<IntComparisonExp>;
  readonly followers_count?: InputMaybe<IntComparisonExp>;
  readonly follows?: InputMaybe<FollowsBoolExp>;
  readonly follows_aggregate?: InputMaybe<FollowsAggregateBoolExp>;
  readonly gender_id?: InputMaybe<SmallintComparisonExp>;
  readonly given_name?: InputMaybe<StringComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly introduction?: InputMaybe<StringComparisonExp>;
  readonly is_active?: InputMaybe<BooleanComparisonExp>;
  readonly last_seen?: InputMaybe<TimestamptzComparisonExp>;
  readonly plan?: InputMaybe<AppPlanEnumComparisonExp>;
  readonly role?: InputMaybe<AppRoleEnumComparisonExp>;
  readonly surname?: InputMaybe<StringComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly user_metric?: InputMaybe<UserMetricsBoolExp>;
  readonly username?: InputMaybe<StringComparisonExp>;
}

/** unique or primary key constraints on table "user_profiles" */
export type UserProfilesConstraint =
  /** unique or primary key constraint on columns "id" */
  | "user_profiles_pkey"
  /** unique or primary key constraint on columns "id" */
  | "users_auth_id_key"
  /** unique or primary key constraint on columns "email" */
  | "users_email_key";

/** input type for incrementing numeric columns in table "user_profiles" */
export interface UserProfilesIncInput {
  readonly followed_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly followers_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly gender_id?: InputMaybe<Scalars["smallint"]["input"]>;
}

/** input type for inserting data into table "user_profiles" */
export interface UserProfilesInsertInput {
  readonly addresses?: InputMaybe<AddressesArrRelInsertInput>;
  readonly avatar?: InputMaybe<Scalars["String"]["input"]>;
  readonly comments?: InputMaybe<CommentsArrRelInsertInput>;
  readonly company_employees?: InputMaybe<CompanyEmployeesArrRelInsertInput>;
  readonly contacts?: InputMaybe<ContactsArrRelInsertInput>;
  readonly content_source_visits?: InputMaybe<ContentSourceVisitsArrRelInsertInput>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly customer_payments?: InputMaybe<CustomerPaymentsArrRelInsertInput>;
  readonly customer_subscriptions?: InputMaybe<CustomerSubscriptionsArrRelInsertInput>;
  readonly dob?: InputMaybe<Scalars["date"]["input"]>;
  readonly email?: InputMaybe<Scalars["String"]["input"]>;
  readonly feedbacks?: InputMaybe<FeedbacksArrRelInsertInput>;
  readonly feeds?: InputMaybe<FeedsArrRelInsertInput>;
  readonly followed_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly followers_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly follows?: InputMaybe<FollowsArrRelInsertInput>;
  readonly gender_id?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly given_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly introduction?: InputMaybe<Scalars["String"]["input"]>;
  readonly is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly last_seen?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly plan?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
  readonly role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  readonly surname?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly user_metric?: InputMaybe<UserMetricsObjRelInsertInput>;
  readonly username?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate max on columns */
export interface UserProfilesMaxFields {
  readonly avatar?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly dob?: Maybe<Scalars["date"]["output"]>;
  readonly email?: Maybe<Scalars["String"]["output"]>;
  readonly followed_count?: Maybe<Scalars["Int"]["output"]>;
  readonly followers_count?: Maybe<Scalars["Int"]["output"]>;
  readonly gender_id?: Maybe<Scalars["smallint"]["output"]>;
  readonly given_name?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly introduction?: Maybe<Scalars["String"]["output"]>;
  readonly last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly plan?: Maybe<Scalars["app_plan_enum"]["output"]>;
  readonly role?: Maybe<Scalars["app_role_enum"]["output"]>;
  readonly surname?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly username?: Maybe<Scalars["String"]["output"]>;
}

/** aggregate min on columns */
export interface UserProfilesMinFields {
  readonly avatar?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly dob?: Maybe<Scalars["date"]["output"]>;
  readonly email?: Maybe<Scalars["String"]["output"]>;
  readonly followed_count?: Maybe<Scalars["Int"]["output"]>;
  readonly followers_count?: Maybe<Scalars["Int"]["output"]>;
  readonly gender_id?: Maybe<Scalars["smallint"]["output"]>;
  readonly given_name?: Maybe<Scalars["String"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly introduction?: Maybe<Scalars["String"]["output"]>;
  readonly last_seen?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly plan?: Maybe<Scalars["app_plan_enum"]["output"]>;
  readonly role?: Maybe<Scalars["app_role_enum"]["output"]>;
  readonly surname?: Maybe<Scalars["String"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly username?: Maybe<Scalars["String"]["output"]>;
}

/** response of any mutation on the table "user_profiles" */
export interface UserProfilesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<UserProfiles>;
}

/** input type for inserting object relation for remote table "user_profiles" */
export interface UserProfilesObjRelInsertInput {
  readonly data: UserProfilesInsertInput;
  /** upsert condition */
  readonly on_conflict?: InputMaybe<UserProfilesOnConflict>;
}

/** on_conflict condition type for table "user_profiles" */
export interface UserProfilesOnConflict {
  readonly constraint: UserProfilesConstraint;
  readonly update_columns: ReadonlyArray<UserProfilesUpdateColumn>;
  readonly where?: InputMaybe<UserProfilesBoolExp>;
}

/** Ordering options when selecting data from "user_profiles". */
export interface UserProfilesOrderBy {
  readonly addresses_aggregate?: InputMaybe<AddressesAggregateOrderBy>;
  readonly avatar?: InputMaybe<OrderBy>;
  readonly comments_aggregate?: InputMaybe<CommentsAggregateOrderBy>;
  readonly company_employees_aggregate?: InputMaybe<CompanyEmployeesAggregateOrderBy>;
  readonly contacts_aggregate?: InputMaybe<ContactsAggregateOrderBy>;
  readonly content_source_visits_aggregate?: InputMaybe<ContentSourceVisitsAggregateOrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly customer_payments_aggregate?: InputMaybe<CustomerPaymentsAggregateOrderBy>;
  readonly customer_subscriptions_aggregate?: InputMaybe<CustomerSubscriptionsAggregateOrderBy>;
  readonly dob?: InputMaybe<OrderBy>;
  readonly email?: InputMaybe<OrderBy>;
  readonly feedbacks_aggregate?: InputMaybe<FeedbacksAggregateOrderBy>;
  readonly feeds_aggregate?: InputMaybe<FeedsAggregateOrderBy>;
  readonly followed_count?: InputMaybe<OrderBy>;
  readonly followers_count?: InputMaybe<OrderBy>;
  readonly follows_aggregate?: InputMaybe<FollowsAggregateOrderBy>;
  readonly gender_id?: InputMaybe<OrderBy>;
  readonly given_name?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly introduction?: InputMaybe<OrderBy>;
  readonly is_active?: InputMaybe<OrderBy>;
  readonly last_seen?: InputMaybe<OrderBy>;
  readonly plan?: InputMaybe<OrderBy>;
  readonly role?: InputMaybe<OrderBy>;
  readonly surname?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
  readonly user_metric?: InputMaybe<UserMetricsOrderBy>;
  readonly username?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: user_profiles */
export interface UserProfilesPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** select columns of table "user_profiles" */
export type UserProfilesSelectColumn =
  /** column name */
  | "avatar"
  /** column name */
  | "created_at"
  /** column name */
  | "dob"
  /** column name */
  | "email"
  /** column name */
  | "followed_count"
  /** column name */
  | "followers_count"
  /** column name */
  | "gender_id"
  /** column name */
  | "given_name"
  /** column name */
  | "id"
  /** column name */
  | "introduction"
  /** column name */
  | "is_active"
  /** column name */
  | "last_seen"
  /** column name */
  | "plan"
  /** column name */
  | "role"
  /** column name */
  | "surname"
  /** column name */
  | "updated_at"
  /** column name */
  | "username";

/** input type for updating data in table "user_profiles" */
export interface UserProfilesSetInput {
  readonly avatar?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly dob?: InputMaybe<Scalars["date"]["input"]>;
  readonly email?: InputMaybe<Scalars["String"]["input"]>;
  readonly followed_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly followers_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly gender_id?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly given_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly introduction?: InputMaybe<Scalars["String"]["input"]>;
  readonly is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly last_seen?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly plan?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
  readonly role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  readonly surname?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly username?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate stddev on columns */
export interface UserProfilesStddevFields {
  readonly followed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly followers_count?: Maybe<Scalars["Float"]["output"]>;
  readonly gender_id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface UserProfilesStddevPopFields {
  readonly followed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly followers_count?: Maybe<Scalars["Float"]["output"]>;
  readonly gender_id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface UserProfilesStddevSampFields {
  readonly followed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly followers_count?: Maybe<Scalars["Float"]["output"]>;
  readonly gender_id?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "user_profiles" */
export interface UserProfilesStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: UserProfilesStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface UserProfilesStreamCursorValueInput {
  readonly avatar?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly dob?: InputMaybe<Scalars["date"]["input"]>;
  readonly email?: InputMaybe<Scalars["String"]["input"]>;
  readonly followed_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly followers_count?: InputMaybe<Scalars["Int"]["input"]>;
  readonly gender_id?: InputMaybe<Scalars["smallint"]["input"]>;
  readonly given_name?: InputMaybe<Scalars["String"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly introduction?: InputMaybe<Scalars["String"]["input"]>;
  readonly is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
  readonly last_seen?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly plan?: InputMaybe<Scalars["app_plan_enum"]["input"]>;
  readonly role?: InputMaybe<Scalars["app_role_enum"]["input"]>;
  readonly surname?: InputMaybe<Scalars["String"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly username?: InputMaybe<Scalars["String"]["input"]>;
}

/** aggregate sum on columns */
export interface UserProfilesSumFields {
  readonly followed_count?: Maybe<Scalars["Int"]["output"]>;
  readonly followers_count?: Maybe<Scalars["Int"]["output"]>;
  readonly gender_id?: Maybe<Scalars["smallint"]["output"]>;
}

/** update columns of table "user_profiles" */
export type UserProfilesUpdateColumn =
  /** column name */
  | "avatar"
  /** column name */
  | "created_at"
  /** column name */
  | "dob"
  /** column name */
  | "email"
  /** column name */
  | "followed_count"
  /** column name */
  | "followers_count"
  /** column name */
  | "gender_id"
  /** column name */
  | "given_name"
  /** column name */
  | "id"
  /** column name */
  | "introduction"
  /** column name */
  | "is_active"
  /** column name */
  | "last_seen"
  /** column name */
  | "plan"
  /** column name */
  | "role"
  /** column name */
  | "surname"
  /** column name */
  | "updated_at"
  /** column name */
  | "username";

export interface UserProfilesUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<UserProfilesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<UserProfilesSetInput>;
  /** filter the rows which have to be updated */
  readonly where: UserProfilesBoolExp;
}

/** aggregate var_pop on columns */
export interface UserProfilesVarPopFields {
  readonly followed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly followers_count?: Maybe<Scalars["Float"]["output"]>;
  readonly gender_id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface UserProfilesVarSampFields {
  readonly followed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly followers_count?: Maybe<Scalars["Float"]["output"]>;
  readonly gender_id?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface UserProfilesVarianceFields {
  readonly followed_count?: Maybe<Scalars["Float"]["output"]>;
  readonly followers_count?: Maybe<Scalars["Float"]["output"]>;
  readonly gender_id?: Maybe<Scalars["Float"]["output"]>;
}

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

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

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

/** columns and relationships of "votes" */
export interface Votes {
  readonly content_id: Scalars["uuid"]["output"];
  readonly content_type: Scalars["String"]["output"];
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  readonly user_id: Scalars["uuid"]["output"];
  readonly vote_type: Scalars["smallint"]["output"];
}

/** aggregated selection of "votes" */
export interface VotesAggregate {
  readonly aggregate?: Maybe<VotesAggregateFields>;
  readonly nodes: ReadonlyArray<Votes>;
}

/** aggregate fields of "votes" */
export interface VotesAggregateFields {
  readonly avg?: Maybe<VotesAvgFields>;
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<VotesMaxFields>;
  readonly min?: Maybe<VotesMinFields>;
  readonly stddev?: Maybe<VotesStddevFields>;
  readonly stddev_pop?: Maybe<VotesStddevPopFields>;
  readonly stddev_samp?: Maybe<VotesStddevSampFields>;
  readonly sum?: Maybe<VotesSumFields>;
  readonly var_pop?: Maybe<VotesVarPopFields>;
  readonly var_samp?: Maybe<VotesVarSampFields>;
  readonly variance?: Maybe<VotesVarianceFields>;
}

/** aggregate fields of "votes" */
export type VotesAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<VotesSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

/** aggregate avg on columns */
export interface VotesAvgFields {
  readonly vote_type?: Maybe<Scalars["Float"]["output"]>;
}

/** Boolean expression to filter rows from the table "votes". All fields are combined with a logical 'AND'. */
export interface VotesBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<VotesBoolExp>>;
  readonly _not?: InputMaybe<VotesBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<VotesBoolExp>>;
  readonly content_id?: InputMaybe<UuidComparisonExp>;
  readonly content_type?: InputMaybe<StringComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly user_id?: InputMaybe<UuidComparisonExp>;
  readonly vote_type?: InputMaybe<SmallintComparisonExp>;
}

/** unique or primary key constraints on table "votes" */
export type VotesConstraint =
  /** unique or primary key constraint on columns "id" */
  | "votes_pkey"
  /** unique or primary key constraint on columns "content_id", "user_id", "content_type" */
  | "votes_unique_user_content_vote_idx";

/** input type for incrementing numeric columns in table "votes" */
export interface VotesIncInput {
  readonly vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
}

/** input type for inserting data into table "votes" */
export interface VotesInsertInput {
  readonly content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly content_type?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
}

/** aggregate max on columns */
export interface VotesMaxFields {
  readonly content_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly content_type?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly vote_type?: Maybe<Scalars["smallint"]["output"]>;
}

/** aggregate min on columns */
export interface VotesMinFields {
  readonly content_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly content_type?: Maybe<Scalars["String"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly user_id?: Maybe<Scalars["uuid"]["output"]>;
  readonly vote_type?: Maybe<Scalars["smallint"]["output"]>;
}

/** response of any mutation on the table "votes" */
export interface VotesMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Votes>;
}

/** on_conflict condition type for table "votes" */
export interface VotesOnConflict {
  readonly constraint: VotesConstraint;
  readonly update_columns: ReadonlyArray<VotesUpdateColumn>;
  readonly where?: InputMaybe<VotesBoolExp>;
}

/** Ordering options when selecting data from "votes". */
export interface VotesOrderBy {
  readonly content_id?: InputMaybe<OrderBy>;
  readonly content_type?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly user_id?: InputMaybe<OrderBy>;
  readonly vote_type?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: votes */
export interface VotesPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

/** select columns of table "votes" */
export type VotesSelectColumn =
  /** column name */
  | "content_id"
  /** column name */
  | "content_type"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "user_id"
  /** column name */
  | "vote_type";

/** input type for updating data in table "votes" */
export interface VotesSetInput {
  readonly content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly content_type?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
}

/** aggregate stddev on columns */
export interface VotesStddevFields {
  readonly vote_type?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_pop on columns */
export interface VotesStddevPopFields {
  readonly vote_type?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate stddev_samp on columns */
export interface VotesStddevSampFields {
  readonly vote_type?: Maybe<Scalars["Float"]["output"]>;
}

/** Streaming cursor of the table "votes" */
export interface VotesStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: VotesStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface VotesStreamCursorValueInput {
  readonly content_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly content_type?: InputMaybe<Scalars["String"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly user_id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly vote_type?: InputMaybe<Scalars["smallint"]["input"]>;
}

/** aggregate sum on columns */
export interface VotesSumFields {
  readonly vote_type?: Maybe<Scalars["smallint"]["output"]>;
}

/** update columns of table "votes" */
export type VotesUpdateColumn =
  /** column name */
  | "content_id"
  /** column name */
  | "content_type"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "user_id"
  /** column name */
  | "vote_type";

export interface VotesUpdates {
  /** increments the numeric columns with given value of the filtered values */
  readonly _inc?: InputMaybe<VotesIncInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<VotesSetInput>;
  /** filter the rows which have to be updated */
  readonly where: VotesBoolExp;
}

/** aggregate var_pop on columns */
export interface VotesVarPopFields {
  readonly vote_type?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate var_samp on columns */
export interface VotesVarSampFields {
  readonly vote_type?: Maybe<Scalars["Float"]["output"]>;
}

/** aggregate variance on columns */
export interface VotesVarianceFields {
  readonly vote_type?: Maybe<Scalars["Float"]["output"]>;
}

/** columns and relationships of "workflows" */
export interface Workflows {
  readonly completed_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id: Scalars["uuid"]["output"];
  readonly metadata?: Maybe<Scalars["jsonb"]["output"]>;
  readonly name: Scalars["String"]["output"];
  readonly started_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly status: Scalars["job_status"]["output"];
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

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

/** aggregated selection of "workflows" */
export interface WorkflowsAggregate {
  readonly aggregate?: Maybe<WorkflowsAggregateFields>;
  readonly nodes: ReadonlyArray<Workflows>;
}

/** aggregate fields of "workflows" */
export interface WorkflowsAggregateFields {
  readonly count: Scalars["Int"]["output"];
  readonly max?: Maybe<WorkflowsMaxFields>;
  readonly min?: Maybe<WorkflowsMinFields>;
}

/** aggregate fields of "workflows" */
export type WorkflowsAggregateFieldsCountArgs = {
  columns?: InputMaybe<ReadonlyArray<WorkflowsSelectColumn>>;
  distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};

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

/** Boolean expression to filter rows from the table "workflows". All fields are combined with a logical 'AND'. */
export interface WorkflowsBoolExp {
  readonly _and?: InputMaybe<ReadonlyArray<WorkflowsBoolExp>>;
  readonly _not?: InputMaybe<WorkflowsBoolExp>;
  readonly _or?: InputMaybe<ReadonlyArray<WorkflowsBoolExp>>;
  readonly completed_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly created_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly id?: InputMaybe<UuidComparisonExp>;
  readonly metadata?: InputMaybe<JsonbComparisonExp>;
  readonly name?: InputMaybe<StringComparisonExp>;
  readonly started_at?: InputMaybe<TimestamptzComparisonExp>;
  readonly status?: InputMaybe<JobStatusComparisonExp>;
  readonly updated_at?: InputMaybe<TimestamptzComparisonExp>;
}

/** unique or primary key constraints on table "workflows" */
export type WorkflowsConstraint =
  /** unique or primary key constraint on columns "id" */
  "workflows_pkey";

/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
export interface WorkflowsDeleteAtPathInput {
  readonly metadata?: InputMaybe<ReadonlyArray<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 interface WorkflowsDeleteElemInput {
  readonly metadata?: InputMaybe<Scalars["Int"]["input"]>;
}

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

/** input type for inserting data into table "workflows" */
export interface WorkflowsInsertInput {
  readonly completed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly started_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly status?: InputMaybe<Scalars["job_status"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** aggregate max on columns */
export interface WorkflowsMaxFields {
  readonly completed_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly started_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly status?: Maybe<Scalars["job_status"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** aggregate min on columns */
export interface WorkflowsMinFields {
  readonly completed_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly created_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly id?: Maybe<Scalars["uuid"]["output"]>;
  readonly name?: Maybe<Scalars["String"]["output"]>;
  readonly started_at?: Maybe<Scalars["timestamptz"]["output"]>;
  readonly status?: Maybe<Scalars["job_status"]["output"]>;
  readonly updated_at?: Maybe<Scalars["timestamptz"]["output"]>;
}

/** response of any mutation on the table "workflows" */
export interface WorkflowsMutationResponse {
  /** number of rows affected by the mutation */
  readonly affected_rows: Scalars["Int"]["output"];
  /** data from the rows affected by the mutation */
  readonly returning: ReadonlyArray<Workflows>;
}

/** on_conflict condition type for table "workflows" */
export interface WorkflowsOnConflict {
  readonly constraint: WorkflowsConstraint;
  readonly update_columns: ReadonlyArray<WorkflowsUpdateColumn>;
  readonly where?: InputMaybe<WorkflowsBoolExp>;
}

/** Ordering options when selecting data from "workflows". */
export interface WorkflowsOrderBy {
  readonly completed_at?: InputMaybe<OrderBy>;
  readonly created_at?: InputMaybe<OrderBy>;
  readonly id?: InputMaybe<OrderBy>;
  readonly metadata?: InputMaybe<OrderBy>;
  readonly name?: InputMaybe<OrderBy>;
  readonly started_at?: InputMaybe<OrderBy>;
  readonly status?: InputMaybe<OrderBy>;
  readonly updated_at?: InputMaybe<OrderBy>;
}

/** primary key columns input for table: workflows */
export interface WorkflowsPkColumnsInput {
  readonly id: Scalars["uuid"]["input"];
}

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

/** select columns of table "workflows" */
export type WorkflowsSelectColumn =
  /** column name */
  | "completed_at"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "metadata"
  /** column name */
  | "name"
  /** column name */
  | "started_at"
  /** column name */
  | "status"
  /** column name */
  | "updated_at";

/** input type for updating data in table "workflows" */
export interface WorkflowsSetInput {
  readonly completed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly started_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly status?: InputMaybe<Scalars["job_status"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** Streaming cursor of the table "workflows" */
export interface WorkflowsStreamCursorInput {
  /** Stream column input with initial value */
  readonly initial_value: WorkflowsStreamCursorValueInput;
  /** cursor ordering */
  readonly ordering?: InputMaybe<CursorOrdering>;
}

/** Initial value of the column from where the streaming should start */
export interface WorkflowsStreamCursorValueInput {
  readonly completed_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly created_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly id?: InputMaybe<Scalars["uuid"]["input"]>;
  readonly metadata?: InputMaybe<Scalars["jsonb"]["input"]>;
  readonly name?: InputMaybe<Scalars["String"]["input"]>;
  readonly started_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
  readonly status?: InputMaybe<Scalars["job_status"]["input"]>;
  readonly updated_at?: InputMaybe<Scalars["timestamptz"]["input"]>;
}

/** update columns of table "workflows" */
export type WorkflowsUpdateColumn =
  /** column name */
  | "completed_at"
  /** column name */
  | "created_at"
  /** column name */
  | "id"
  /** column name */
  | "metadata"
  /** column name */
  | "name"
  /** column name */
  | "started_at"
  /** column name */
  | "status"
  /** column name */
  | "updated_at";

export interface WorkflowsUpdates {
  /** append existing jsonb value of filtered columns with new jsonb value */
  readonly _append?: InputMaybe<WorkflowsAppendInput>;
  /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */
  readonly _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 */
  readonly _delete_elem?: InputMaybe<WorkflowsDeleteElemInput>;
  /** delete key/value pair or string element. key/value pairs are matched based on their key value */
  readonly _delete_key?: InputMaybe<WorkflowsDeleteKeyInput>;
  /** prepend existing jsonb value of filtered columns with new jsonb value */
  readonly _prepend?: InputMaybe<WorkflowsPrependInput>;
  /** sets the columns of the filtered rows to the given values */
  readonly _set?: InputMaybe<WorkflowsSetInput>;
  /** filter the rows which have to be updated */
  readonly where: WorkflowsBoolExp;
}

export type FetchManyAdDailyMetricQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<AdDailyMetricsSelectColumn> | AdDailyMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<AdDailyMetricsOrderBy> | AdDailyMetricsOrderBy
  >;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
}>;

export type FetchManyAdDailyMetricQueryQuery = {
  readonly ad_daily_metrics: ReadonlyArray<{
    readonly clicks?: number | null;
    readonly created_at?: string | null;
    readonly date: any;
    readonly id: string;
    readonly updated_at?: string | null;
    readonly variant_id?: string | null;
    readonly views?: number | null;
    readonly ad_variant?: {
      readonly active?: boolean | null;
      readonly ad_id: string;
      readonly content: Record<string, any>;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_control?: boolean | null;
      readonly performance_metrics?: Record<string, any> | null;
      readonly updated_at?: string | null;
    } | null;
  }>;
};

export type CountAdDailyMetricQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<AdDailyMetricsSelectColumn> | AdDailyMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<AdDailyMetricsOrderBy> | AdDailyMetricsOrderBy
  >;
  where?: InputMaybe<AdDailyMetricsBoolExp>;
}>;

export type CountAdDailyMetricQueryQuery = {
  readonly ad_daily_metrics_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly clicks?: number | null;
      readonly created_at?: string | null;
      readonly date: any;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly variant_id?: string | null;
      readonly views?: number | null;
    }>;
  };
};

export type FetchOneAdDailyMetricQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneAdDailyMetricQueryQuery = {
  readonly ad_daily_metrics_by_pk?: {
    readonly clicks?: number | null;
    readonly created_at?: string | null;
    readonly date: any;
    readonly id: string;
    readonly updated_at?: string | null;
    readonly variant_id?: string | null;
    readonly views?: number | null;
    readonly ad_variant?: {
      readonly active?: boolean | null;
      readonly ad_id: string;
      readonly content: Record<string, any>;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_control?: boolean | null;
      readonly performance_metrics?: Record<string, any> | null;
      readonly updated_at?: string | null;
    } | null;
  } | null;
};

export type FetchManyAdPackageQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<AdPackagesSelectColumn> | AdPackagesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdPackagesOrderBy> | AdPackagesOrderBy>;
  where?: InputMaybe<AdPackagesBoolExp>;
}>;

export type FetchManyAdPackageQueryQuery = {
  readonly ad_packages: ReadonlyArray<{
    readonly active?: boolean | null;
    readonly avg_roi?: number | null;
    readonly created_at?: string | null;
    readonly description: string;
    readonly expected_ctr?: number | null;
    readonly features: ReadonlyArray<string>;
    readonly id: string;
    readonly name: string;
    readonly position: string;
    readonly price: number;
    readonly updated_at?: string | null;
    readonly view_frequency?: number | null;
    readonly ads: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    }>;
  }>;
};

export type CountAdPackageQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<AdPackagesSelectColumn> | AdPackagesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdPackagesOrderBy> | AdPackagesOrderBy>;
  where?: InputMaybe<AdPackagesBoolExp>;
}>;

export type CountAdPackageQueryQuery = {
  readonly ad_packages_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly avg_roi?: number | null;
      readonly created_at?: string | null;
      readonly description: string;
      readonly expected_ctr?: number | null;
      readonly features: ReadonlyArray<string>;
      readonly id: string;
      readonly name: string;
      readonly position: string;
      readonly price: number;
      readonly updated_at?: string | null;
      readonly view_frequency?: number | null;
    }>;
  };
};

export type FetchOneAdPackageQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneAdPackageQueryQuery = {
  readonly ad_packages_by_pk?: {
    readonly active?: boolean | null;
    readonly avg_roi?: number | null;
    readonly created_at?: string | null;
    readonly description: string;
    readonly expected_ctr?: number | null;
    readonly features: ReadonlyArray<string>;
    readonly id: string;
    readonly name: string;
    readonly position: string;
    readonly price: number;
    readonly updated_at?: string | null;
    readonly view_frequency?: number | null;
    readonly ads: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type FetchManyAdVariantQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<AdVariantsSelectColumn> | AdVariantsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdVariantsOrderBy> | AdVariantsOrderBy>;
  where?: InputMaybe<AdVariantsBoolExp>;
}>;

export type FetchManyAdVariantQueryQuery = {
  readonly ad_variants: ReadonlyArray<{
    readonly active?: boolean | null;
    readonly ad_id: string;
    readonly content: Record<string, any>;
    readonly created_at?: string | null;
    readonly id: string;
    readonly is_control?: boolean | null;
    readonly performance_metrics?: Record<string, any> | null;
    readonly updated_at?: string | null;
    readonly ad: {
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    };
    readonly ad_daily_metrics: ReadonlyArray<{
      readonly clicks?: number | null;
      readonly created_at?: string | null;
      readonly date: any;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly variant_id?: string | null;
      readonly views?: number | null;
    }>;
  }>;
};

export type CountAdVariantQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<AdVariantsSelectColumn> | AdVariantsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdVariantsOrderBy> | AdVariantsOrderBy>;
  where?: InputMaybe<AdVariantsBoolExp>;
}>;

export type CountAdVariantQueryQuery = {
  readonly ad_variants_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly ad_id: string;
      readonly content: Record<string, any>;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_control?: boolean | null;
      readonly performance_metrics?: Record<string, any> | null;
      readonly updated_at?: string | null;
    }>;
  };
};

export type FetchOneAdVariantQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneAdVariantQueryQuery = {
  readonly ad_variants_by_pk?: {
    readonly active?: boolean | null;
    readonly ad_id: string;
    readonly content: Record<string, any>;
    readonly created_at?: string | null;
    readonly id: string;
    readonly is_control?: boolean | null;
    readonly performance_metrics?: Record<string, any> | null;
    readonly updated_at?: string | null;
    readonly ad: {
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    };
    readonly ad_daily_metrics: ReadonlyArray<{
      readonly clicks?: number | null;
      readonly created_at?: string | null;
      readonly date: any;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly variant_id?: string | null;
      readonly views?: number | null;
    }>;
  } | null;
};

export type FetchManyAddressQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<AddressesSelectColumn> | AddressesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AddressesOrderBy> | AddressesOrderBy>;
  where?: InputMaybe<AddressesBoolExp>;
}>;

export type FetchManyAddressQueryQuery = {
  readonly addresses: ReadonlyArray<{
    readonly address_type?: any | null;
    readonly city_id: number;
    readonly company_id?: string | null;
    readonly country_id: number;
    readonly created_at?: string | null;
    readonly id: number;
    readonly is_primary?: boolean | null;
    readonly name?: string | null;
    readonly street1: string;
    readonly street2?: string | null;
    readonly updated_at?: string | null;
    readonly user_id?: string | null;
    readonly city: {
      readonly country_id: number;
      readonly id: number;
      readonly name: string;
      readonly state?: string | null;
    };
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly country: {
      readonly code: string;
      readonly code_3?: string | null;
      readonly id: number;
      readonly name: string;
    };
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  }>;
};

export type CountAddressQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<AddressesSelectColumn> | AddressesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AddressesOrderBy> | AddressesOrderBy>;
  where?: InputMaybe<AddressesBoolExp>;
}>;

export type CountAddressQueryQuery = {
  readonly addresses_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
  };
};

export type FetchOneAddressQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneAddressQueryQuery = {
  readonly addresses_by_pk?: {
    readonly address_type?: any | null;
    readonly city_id: number;
    readonly company_id?: string | null;
    readonly country_id: number;
    readonly created_at?: string | null;
    readonly id: number;
    readonly is_primary?: boolean | null;
    readonly name?: string | null;
    readonly street1: string;
    readonly street2?: string | null;
    readonly updated_at?: string | null;
    readonly user_id?: string | null;
    readonly city: {
      readonly country_id: number;
      readonly id: number;
      readonly name: string;
      readonly state?: string | null;
    };
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly country: {
      readonly code: string;
      readonly code_3?: string | null;
      readonly id: number;
      readonly name: string;
    };
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type FetchManyAdQueryVariables = Exact<{
  distinct_on?: InputMaybe<ReadonlyArray<AdsSelectColumn> | AdsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdsOrderBy> | AdsOrderBy>;
  where?: InputMaybe<AdsBoolExp>;
}>;

export type FetchManyAdQueryQuery = {
  readonly ads: ReadonlyArray<{
    readonly active?: boolean | null;
    readonly company_id?: string | null;
    readonly created_at?: string | null;
    readonly end_date: string;
    readonly id: string;
    readonly package_id?: string | null;
    readonly start_date: string;
    readonly updated_at?: string | null;
    readonly ad_package?: {
      readonly active?: boolean | null;
      readonly avg_roi?: number | null;
      readonly created_at?: string | null;
      readonly description: string;
      readonly expected_ctr?: number | null;
      readonly features: ReadonlyArray<string>;
      readonly id: string;
      readonly name: string;
      readonly position: string;
      readonly price: number;
      readonly updated_at?: string | null;
      readonly view_frequency?: number | null;
    } | null;
    readonly ad_variants: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly ad_id: string;
      readonly content: Record<string, any>;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_control?: boolean | null;
      readonly performance_metrics?: Record<string, any> | null;
      readonly updated_at?: string | null;
    }>;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  }>;
};

export type CountAdQueryVariables = Exact<{
  distinct_on?: InputMaybe<ReadonlyArray<AdsSelectColumn> | AdsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<AdsOrderBy> | AdsOrderBy>;
  where?: InputMaybe<AdsBoolExp>;
}>;

export type CountAdQueryQuery = {
  readonly ads_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    }>;
  };
};

export type FetchOneAdQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneAdQueryQuery = {
  readonly ads_by_pk?: {
    readonly active?: boolean | null;
    readonly company_id?: string | null;
    readonly created_at?: string | null;
    readonly end_date: string;
    readonly id: string;
    readonly package_id?: string | null;
    readonly start_date: string;
    readonly updated_at?: string | null;
    readonly ad_package?: {
      readonly active?: boolean | null;
      readonly avg_roi?: number | null;
      readonly created_at?: string | null;
      readonly description: string;
      readonly expected_ctr?: number | null;
      readonly features: ReadonlyArray<string>;
      readonly id: string;
      readonly name: string;
      readonly position: string;
      readonly price: number;
      readonly updated_at?: string | null;
      readonly view_frequency?: number | null;
    } | null;
    readonly ad_variants: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly ad_id: string;
      readonly content: Record<string, any>;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_control?: boolean | null;
      readonly performance_metrics?: Record<string, any> | null;
      readonly updated_at?: string | null;
    }>;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type FetchManyBlacklistedDomainQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<BlacklistedDomainsSelectColumn>
    | BlacklistedDomainsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<BlacklistedDomainsOrderBy> | BlacklistedDomainsOrderBy
  >;
  where?: InputMaybe<BlacklistedDomainsBoolExp>;
}>;

export type FetchManyBlacklistedDomainQueryQuery = {
  readonly blacklisted_domains: ReadonlyArray<{
    readonly created_at: string;
    readonly id: string;
    readonly reason?: string | null;
    readonly url: string;
  }>;
};

export type CountBlacklistedDomainQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<BlacklistedDomainsSelectColumn>
    | BlacklistedDomainsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<BlacklistedDomainsOrderBy> | BlacklistedDomainsOrderBy
  >;
  where?: InputMaybe<BlacklistedDomainsBoolExp>;
}>;

export type CountBlacklistedDomainQueryQuery = {
  readonly blacklisted_domains_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly created_at: string;
      readonly id: string;
      readonly reason?: string | null;
      readonly url: string;
    }>;
  };
};

export type FetchOneBlacklistedDomainQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneBlacklistedDomainQueryQuery = {
  readonly blacklisted_domains_by_pk?: {
    readonly created_at: string;
    readonly id: string;
    readonly reason?: string | null;
    readonly url: string;
  } | null;
};

export type FetchManyBlacklistedUrlQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<BlacklistedUrlsSelectColumn> | BlacklistedUrlsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<BlacklistedUrlsOrderBy> | BlacklistedUrlsOrderBy
  >;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
}>;

export type FetchManyBlacklistedUrlQueryQuery = {
  readonly blacklisted_urls: ReadonlyArray<{
    readonly company_id?: string | null;
    readonly created_at?: string | null;
    readonly id: number;
    readonly reason?: string | null;
    readonly url: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  }>;
};

export type CountBlacklistedUrlQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<BlacklistedUrlsSelectColumn> | BlacklistedUrlsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<BlacklistedUrlsOrderBy> | BlacklistedUrlsOrderBy
  >;
  where?: InputMaybe<BlacklistedUrlsBoolExp>;
}>;

export type CountBlacklistedUrlQueryQuery = {
  readonly blacklisted_urls_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly id: number;
      readonly reason?: string | null;
      readonly url: string;
    }>;
  };
};

export type FetchOneBlacklistedUrlQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneBlacklistedUrlQueryQuery = {
  readonly blacklisted_urls_by_pk?: {
    readonly company_id?: string | null;
    readonly created_at?: string | null;
    readonly id: number;
    readonly reason?: string | null;
    readonly url: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type FetchManyBlockedIpQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<BlockedIpsSelectColumn> | BlockedIpsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BlockedIpsOrderBy> | BlockedIpsOrderBy>;
  where?: InputMaybe<BlockedIpsBoolExp>;
}>;

export type FetchManyBlockedIpQueryQuery = {
  readonly blocked_ips: ReadonlyArray<{
    readonly blocked_at?: string | null;
    readonly blocked_until: string;
    readonly created_at?: string | null;
    readonly failed_attempts?: number | null;
    readonly id: string;
    readonly ip_address: any;
    readonly reason?: string | null;
    readonly updated_at?: string | null;
  }>;
};

export type CountBlockedIpQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<BlockedIpsSelectColumn> | BlockedIpsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BlockedIpsOrderBy> | BlockedIpsOrderBy>;
  where?: InputMaybe<BlockedIpsBoolExp>;
}>;

export type CountBlockedIpQueryQuery = {
  readonly blocked_ips_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly blocked_at?: string | null;
      readonly blocked_until: string;
      readonly created_at?: string | null;
      readonly failed_attempts?: number | null;
      readonly id: string;
      readonly ip_address: any;
      readonly reason?: string | null;
      readonly updated_at?: string | null;
    }>;
  };
};

export type FetchOneBlockedIpQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneBlockedIpQueryQuery = {
  readonly blocked_ips_by_pk?: {
    readonly blocked_at?: string | null;
    readonly blocked_until: string;
    readonly created_at?: string | null;
    readonly failed_attempts?: number | null;
    readonly id: string;
    readonly ip_address: any;
    readonly reason?: string | null;
    readonly updated_at?: string | null;
  } | null;
};

export type FetchManyBookmarkFolderQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<BookmarkFoldersSelectColumn> | BookmarkFoldersSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<BookmarkFoldersOrderBy> | BookmarkFoldersOrderBy
  >;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
}>;

export type FetchManyBookmarkFolderQueryQuery = {
  readonly bookmark_folders: ReadonlyArray<{
    readonly color?: string | null;
    readonly created_at?: string | null;
    readonly id: string;
    readonly is_default?: boolean | null;
    readonly is_favorite?: boolean | null;
    readonly name: string;
    readonly parent_id?: string | null;
    readonly path?: any | null;
    readonly position?: number | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly bookmarks: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly folder_id?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  }>;
};

export type CountBookmarkFolderQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<BookmarkFoldersSelectColumn> | BookmarkFoldersSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<BookmarkFoldersOrderBy> | BookmarkFoldersOrderBy
  >;
  where?: InputMaybe<BookmarkFoldersBoolExp>;
}>;

export type CountBookmarkFolderQueryQuery = {
  readonly bookmark_folders_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly color?: string | null;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_default?: boolean | null;
      readonly is_favorite?: boolean | null;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly path?: any | null;
      readonly position?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  };
};

export type FetchOneBookmarkFolderQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneBookmarkFolderQueryQuery = {
  readonly bookmark_folders_by_pk?: {
    readonly color?: string | null;
    readonly created_at?: string | null;
    readonly id: string;
    readonly is_default?: boolean | null;
    readonly is_favorite?: boolean | null;
    readonly name: string;
    readonly parent_id?: string | null;
    readonly path?: any | null;
    readonly position?: number | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly bookmarks: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly folder_id?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  } | null;
};

export type FetchManyBookmarkQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<BookmarksSelectColumn> | BookmarksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BookmarksOrderBy> | BookmarksOrderBy>;
  where?: InputMaybe<BookmarksBoolExp>;
}>;

export type FetchManyBookmarkQueryQuery = {
  readonly bookmarks: ReadonlyArray<{
    readonly content_id: string;
    readonly content_type: string;
    readonly created_at?: string | null;
    readonly folder_id?: string | null;
    readonly id: string;
    readonly metadata?: Record<string, any> | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly bookmark_folder?: {
      readonly color?: string | null;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_default?: boolean | null;
      readonly is_favorite?: boolean | null;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly path?: any | null;
      readonly position?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    } | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  }>;
};

export type CountBookmarkQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<BookmarksSelectColumn> | BookmarksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<BookmarksOrderBy> | BookmarksOrderBy>;
  where?: InputMaybe<BookmarksBoolExp>;
}>;

export type CountBookmarkQueryQuery = {
  readonly bookmarks_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly folder_id?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  };
};

export type FetchOneBookmarkQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneBookmarkQueryQuery = {
  readonly bookmarks_by_pk?: {
    readonly content_id: string;
    readonly content_type: string;
    readonly created_at?: string | null;
    readonly folder_id?: string | null;
    readonly id: string;
    readonly metadata?: Record<string, any> | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly bookmark_folder?: {
      readonly color?: string | null;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_default?: boolean | null;
      readonly is_favorite?: boolean | null;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly path?: any | null;
      readonly position?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    } | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type FetchManyBusinessDomainQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<BusinessDomainsSelectColumn> | BusinessDomainsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<BusinessDomainsOrderBy> | BusinessDomainsOrderBy
  >;
  where?: InputMaybe<BusinessDomainsBoolExp>;
}>;

export type FetchManyBusinessDomainQueryQuery = {
  readonly business_domains: ReadonlyArray<{
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly id: string;
    readonly name: string;
    readonly parent_id?: string | null;
    readonly slug: string;
    readonly updated_at?: string | null;
    readonly categorized_urls: ReadonlyArray<{
      readonly categorizer_version: string;
      readonly company_id?: string | null;
      readonly confidence: number;
      readonly content_hash?: string | null;
      readonly created_at?: string | null;
      readonly domain_id: string;
      readonly found_on?: string | null;
      readonly id: string;
      readonly priority?: any | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
  }>;
};

export type CountBusinessDomainQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<BusinessDomainsSelectColumn> | BusinessDomainsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<BusinessDomainsOrderBy> | BusinessDomainsOrderBy
  >;
  where?: InputMaybe<BusinessDomainsBoolExp>;
}>;

export type CountBusinessDomainQueryQuery = {
  readonly business_domains_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly id: string;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly slug: string;
      readonly updated_at?: string | null;
    }>;
  };
};

export type FetchOneBusinessDomainQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneBusinessDomainQueryQuery = {
  readonly business_domains_by_pk?: {
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly id: string;
    readonly name: string;
    readonly parent_id?: string | null;
    readonly slug: string;
    readonly updated_at?: string | null;
    readonly categorized_urls: ReadonlyArray<{
      readonly categorizer_version: string;
      readonly company_id?: string | null;
      readonly confidence: number;
      readonly content_hash?: string | null;
      readonly created_at?: string | null;
      readonly domain_id: string;
      readonly found_on?: string | null;
      readonly id: string;
      readonly priority?: any | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
  } | null;
};

export type FetchManyCategoryQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CategoriesSelectColumn> | CategoriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CategoriesOrderBy> | CategoriesOrderBy>;
  where?: InputMaybe<CategoriesBoolExp>;
}>;

export type FetchManyCategoryQueryQuery = {
  readonly categories: ReadonlyArray<{
    readonly body?: string | null;
    readonly created_at: string;
    readonly document_id?: string | null;
    readonly id: number;
    readonly locale?: string | null;
    readonly name: string;
    readonly published_at?: string | null;
    readonly updated_at?: string | null;
    readonly companies: ReadonlyArray<{
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
    readonly content_categories: ReadonlyArray<{
      readonly category_id: number;
      readonly content_id: string;
      readonly is_primary: boolean;
    }>;
    readonly feed_categories: ReadonlyArray<{
      readonly category_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly news: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
  }>;
};

export type CountCategoryQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CategoriesSelectColumn> | CategoriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CategoriesOrderBy> | CategoriesOrderBy>;
  where?: InputMaybe<CategoriesBoolExp>;
}>;

export type CountCategoryQueryQuery = {
  readonly categories_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    }>;
  };
};

export type FetchOneCategoryQueryVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneCategoryQueryQuery = {
  readonly categories_by_pk?: {
    readonly body?: string | null;
    readonly created_at: string;
    readonly document_id?: string | null;
    readonly id: number;
    readonly locale?: string | null;
    readonly name: string;
    readonly published_at?: string | null;
    readonly updated_at?: string | null;
    readonly companies: ReadonlyArray<{
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
    readonly content_categories: ReadonlyArray<{
      readonly category_id: number;
      readonly content_id: string;
      readonly is_primary: boolean;
    }>;
    readonly feed_categories: ReadonlyArray<{
      readonly category_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly news: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
  } | null;
};

export type FetchManyCategorizedUrlQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CategorizedUrlsSelectColumn> | CategorizedUrlsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CategorizedUrlsOrderBy> | CategorizedUrlsOrderBy
  >;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
}>;

export type FetchManyCategorizedUrlQueryQuery = {
  readonly categorized_urls: ReadonlyArray<{
    readonly categorizer_version: string;
    readonly company_id?: string | null;
    readonly confidence: number;
    readonly content_hash?: string | null;
    readonly created_at?: string | null;
    readonly domain_id: string;
    readonly found_on?: string | null;
    readonly id: string;
    readonly priority?: any | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly business_domain: {
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly id: string;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly slug: string;
      readonly updated_at?: string | null;
    };
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  }>;
};

export type CountCategorizedUrlQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CategorizedUrlsSelectColumn> | CategorizedUrlsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CategorizedUrlsOrderBy> | CategorizedUrlsOrderBy
  >;
  where?: InputMaybe<CategorizedUrlsBoolExp>;
}>;

export type CountCategorizedUrlQueryQuery = {
  readonly categorized_urls_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly categorizer_version: string;
      readonly company_id?: string | null;
      readonly confidence: number;
      readonly content_hash?: string | null;
      readonly created_at?: string | null;
      readonly domain_id: string;
      readonly found_on?: string | null;
      readonly id: string;
      readonly priority?: any | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
  };
};

export type FetchOneCategorizedUrlQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneCategorizedUrlQueryQuery = {
  readonly categorized_urls_by_pk?: {
    readonly categorizer_version: string;
    readonly company_id?: string | null;
    readonly confidence: number;
    readonly content_hash?: string | null;
    readonly created_at?: string | null;
    readonly domain_id: string;
    readonly found_on?: string | null;
    readonly id: string;
    readonly priority?: any | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly business_domain: {
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly id: string;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly slug: string;
      readonly updated_at?: string | null;
    };
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type FetchManyCircuitBreakerStateQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<CircuitBreakerStatesSelectColumn>
    | CircuitBreakerStatesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CircuitBreakerStatesOrderBy> | CircuitBreakerStatesOrderBy
  >;
  where?: InputMaybe<CircuitBreakerStatesBoolExp>;
}>;

export type FetchManyCircuitBreakerStateQueryQuery = {
  readonly circuit_breaker_states: ReadonlyArray<{
    readonly created_at?: string | null;
    readonly failure_count?: number | null;
    readonly id: string;
    readonly job_name: string;
    readonly last_failure?: string | null;
    readonly last_success?: string | null;
    readonly state: string;
    readonly updated_at?: string | null;
  }>;
};

export type CountCircuitBreakerStateQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<CircuitBreakerStatesSelectColumn>
    | CircuitBreakerStatesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CircuitBreakerStatesOrderBy> | CircuitBreakerStatesOrderBy
  >;
  where?: InputMaybe<CircuitBreakerStatesBoolExp>;
}>;

export type CountCircuitBreakerStateQueryQuery = {
  readonly circuit_breaker_states_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly failure_count?: number | null;
      readonly id: string;
      readonly job_name: string;
      readonly last_failure?: string | null;
      readonly last_success?: string | null;
      readonly state: string;
      readonly updated_at?: string | null;
    }>;
  };
};

export type FetchOneCircuitBreakerStateQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneCircuitBreakerStateQueryQuery = {
  readonly circuit_breaker_states_by_pk?: {
    readonly created_at?: string | null;
    readonly failure_count?: number | null;
    readonly id: string;
    readonly job_name: string;
    readonly last_failure?: string | null;
    readonly last_success?: string | null;
    readonly state: string;
    readonly updated_at?: string | null;
  } | null;
};

export type FetchManyCityQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CitiesSelectColumn> | CitiesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CitiesOrderBy> | CitiesOrderBy>;
  where?: InputMaybe<CitiesBoolExp>;
}>;

export type FetchManyCityQueryQuery = {
  readonly cities: ReadonlyArray<{
    readonly country_id: number;
    readonly id: number;
    readonly name: string;
    readonly state?: string | null;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly country: {
      readonly code: string;
      readonly code_3?: string | null;
      readonly id: number;
      readonly name: string;
    };
  }>;
};

export type CountCityQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CitiesSelectColumn> | CitiesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CitiesOrderBy> | CitiesOrderBy>;
  where?: InputMaybe<CitiesBoolExp>;
}>;

export type CountCityQueryQuery = {
  readonly cities_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly country_id: number;
      readonly id: number;
      readonly name: string;
      readonly state?: string | null;
    }>;
  };
};

export type FetchOneCityQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCityQueryQuery = {
  readonly cities_by_pk?: {
    readonly country_id: number;
    readonly id: number;
    readonly name: string;
    readonly state?: string | null;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly country: {
      readonly code: string;
      readonly code_3?: string | null;
      readonly id: number;
      readonly name: string;
    };
  } | null;
};

export type FetchManyCommentQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CommentsSelectColumn> | CommentsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CommentsOrderBy> | CommentsOrderBy>;
  where?: InputMaybe<CommentsBoolExp>;
}>;

export type FetchManyCommentQueryQuery = {
  readonly comments: ReadonlyArray<{
    readonly content: string;
    readonly content_id: string;
    readonly content_type: any;
    readonly created_at?: string | null;
    readonly id: string;
    readonly parent_comment_id?: string | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  }>;
};

export type CountCommentQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CommentsSelectColumn> | CommentsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CommentsOrderBy> | CommentsOrderBy>;
  where?: InputMaybe<CommentsBoolExp>;
}>;

export type CountCommentQueryQuery = {
  readonly comments_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly content: string;
      readonly content_id: string;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly parent_comment_id?: string | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  };
};

export type FetchOneCommentQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneCommentQueryQuery = {
  readonly comments_by_pk?: {
    readonly content: string;
    readonly content_id: string;
    readonly content_type: any;
    readonly created_at?: string | null;
    readonly id: string;
    readonly parent_comment_id?: string | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type FetchManyCompanyQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CompaniesSelectColumn> | CompaniesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompaniesOrderBy> | CompaniesOrderBy>;
  where?: InputMaybe<CompaniesBoolExp>;
}>;

export type FetchManyCompanyQueryQuery = {
  readonly companies: ReadonlyArray<{
    readonly category?: string | null;
    readonly category_id?: number | null;
    readonly content_status: any;
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly failed_count?: any | null;
    readonly founding_year?: any | null;
    readonly id: string;
    readonly is_english?: boolean | null;
    readonly is_government?: boolean | null;
    readonly keywords?: Record<string, any> | null;
    readonly logo_url?: string | null;
    readonly name?: string | null;
    readonly scrape_frequency?: any | null;
    readonly scrape_rating?: any | null;
    readonly scraped_at?: string | null;
    readonly social_media_id?: number | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly ads: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    }>;
    readonly blacklisted_urls: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly id: number;
      readonly reason?: string | null;
      readonly url: string;
    }>;
    readonly categorized_urls: ReadonlyArray<{
      readonly categorizer_version: string;
      readonly company_id?: string | null;
      readonly confidence: number;
      readonly content_hash?: string | null;
      readonly created_at?: string | null;
      readonly domain_id: string;
      readonly found_on?: string | null;
      readonly id: string;
      readonly priority?: any | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
    readonly categoryByCategoryId?: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly company_contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_id: number;
      readonly created_at: string;
      readonly id: number;
      readonly updated_at: string;
    }>;
    readonly company_extras: ReadonlyArray<{
      readonly body?: string | null;
      readonly category: string;
      readonly company_id?: string | null;
      readonly created_at: string;
      readonly found_count?: number | null;
      readonly id: number;
      readonly level: any;
      readonly review?: Record<string, any> | null;
      readonly success?: boolean | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
    readonly contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly content_sources: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
    readonly news: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
    readonly social_medium?: {
      readonly created_at?: string | null;
      readonly facebook_url?: string | null;
      readonly id: number;
      readonly instagram_url?: string | null;
      readonly linkedin_url?: string | null;
      readonly twitter_url?: string | null;
      readonly updated_at?: string | null;
      readonly youtube_url?: string | null;
    } | null;
  }>;
};

export type CountCompanyQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CompaniesSelectColumn> | CompaniesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CompaniesOrderBy> | CompaniesOrderBy>;
  where?: InputMaybe<CompaniesBoolExp>;
}>;

export type CountCompanyQueryQuery = {
  readonly companies_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
  };
};

export type FetchOneCompanyQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneCompanyQueryQuery = {
  readonly companies_by_pk?: {
    readonly category?: string | null;
    readonly category_id?: number | null;
    readonly content_status: any;
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly failed_count?: any | null;
    readonly founding_year?: any | null;
    readonly id: string;
    readonly is_english?: boolean | null;
    readonly is_government?: boolean | null;
    readonly keywords?: Record<string, any> | null;
    readonly logo_url?: string | null;
    readonly name?: string | null;
    readonly scrape_frequency?: any | null;
    readonly scrape_rating?: any | null;
    readonly scraped_at?: string | null;
    readonly social_media_id?: number | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly ads: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    }>;
    readonly blacklisted_urls: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly id: number;
      readonly reason?: string | null;
      readonly url: string;
    }>;
    readonly categorized_urls: ReadonlyArray<{
      readonly categorizer_version: string;
      readonly company_id?: string | null;
      readonly confidence: number;
      readonly content_hash?: string | null;
      readonly created_at?: string | null;
      readonly domain_id: string;
      readonly found_on?: string | null;
      readonly id: string;
      readonly priority?: any | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
    readonly categoryByCategoryId?: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly company_contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_id: number;
      readonly created_at: string;
      readonly id: number;
      readonly updated_at: string;
    }>;
    readonly company_extras: ReadonlyArray<{
      readonly body?: string | null;
      readonly category: string;
      readonly company_id?: string | null;
      readonly created_at: string;
      readonly found_count?: number | null;
      readonly id: number;
      readonly level: any;
      readonly review?: Record<string, any> | null;
      readonly success?: boolean | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
    readonly contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly content_sources: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
    readonly news: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
    readonly social_medium?: {
      readonly created_at?: string | null;
      readonly facebook_url?: string | null;
      readonly id: number;
      readonly instagram_url?: string | null;
      readonly linkedin_url?: string | null;
      readonly twitter_url?: string | null;
      readonly updated_at?: string | null;
      readonly youtube_url?: string | null;
    } | null;
  } | null;
};

export type FetchManyCompanyContactQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CompanyContactsSelectColumn> | CompanyContactsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CompanyContactsOrderBy> | CompanyContactsOrderBy
  >;
  where?: InputMaybe<CompanyContactsBoolExp>;
}>;

export type FetchManyCompanyContactQueryQuery = {
  readonly company_contacts: ReadonlyArray<{
    readonly company_id?: string | null;
    readonly contact_id: number;
    readonly created_at: string;
    readonly id: number;
    readonly updated_at: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly contact: {
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    };
  }>;
};

export type CountCompanyContactQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CompanyContactsSelectColumn> | CompanyContactsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CompanyContactsOrderBy> | CompanyContactsOrderBy
  >;
  where?: InputMaybe<CompanyContactsBoolExp>;
}>;

export type CountCompanyContactQueryQuery = {
  readonly company_contacts_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_id: number;
      readonly created_at: string;
      readonly id: number;
      readonly updated_at: string;
    }>;
  };
};

export type FetchOneCompanyContactQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCompanyContactQueryQuery = {
  readonly company_contacts_by_pk?: {
    readonly company_id?: string | null;
    readonly contact_id: number;
    readonly created_at: string;
    readonly id: number;
    readonly updated_at: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly contact: {
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    };
  } | null;
};

export type FetchManyCompanyEmployeeQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CompanyEmployeesSelectColumn> | CompanyEmployeesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CompanyEmployeesOrderBy> | CompanyEmployeesOrderBy
  >;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
}>;

export type FetchManyCompanyEmployeeQueryQuery = {
  readonly company_employees: ReadonlyArray<{
    readonly access_level: any;
    readonly company_id?: string | null;
    readonly created_at?: string | null;
    readonly end_date?: string | null;
    readonly id: string;
    readonly job_description?: string | null;
    readonly role: string;
    readonly start_date?: string | null;
    readonly status?: boolean | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  }>;
};

export type CountCompanyEmployeeQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CompanyEmployeesSelectColumn> | CompanyEmployeesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CompanyEmployeesOrderBy> | CompanyEmployeesOrderBy
  >;
  where?: InputMaybe<CompanyEmployeesBoolExp>;
}>;

export type CountCompanyEmployeeQueryQuery = {
  readonly company_employees_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly access_level: any;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date?: string | null;
      readonly id: string;
      readonly job_description?: string | null;
      readonly role: string;
      readonly start_date?: string | null;
      readonly status?: boolean | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  };
};

export type FetchOneCompanyEmployeeQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneCompanyEmployeeQueryQuery = {
  readonly company_employees_by_pk?: {
    readonly access_level: any;
    readonly company_id?: string | null;
    readonly created_at?: string | null;
    readonly end_date?: string | null;
    readonly id: string;
    readonly job_description?: string | null;
    readonly role: string;
    readonly start_date?: string | null;
    readonly status?: boolean | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type FetchManyCompanyExtraQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CompanyExtrasSelectColumn> | CompanyExtrasSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CompanyExtrasOrderBy> | CompanyExtrasOrderBy
  >;
  where?: InputMaybe<CompanyExtrasBoolExp>;
}>;

export type FetchManyCompanyExtraQueryQuery = {
  readonly company_extras: ReadonlyArray<{
    readonly body?: string | null;
    readonly category: string;
    readonly company_id?: string | null;
    readonly created_at: string;
    readonly found_count?: number | null;
    readonly id: number;
    readonly level: any;
    readonly review?: Record<string, any> | null;
    readonly success?: boolean | null;
    readonly updated_at: string;
    readonly url: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  }>;
};

export type CountCompanyExtraQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CompanyExtrasSelectColumn> | CompanyExtrasSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CompanyExtrasOrderBy> | CompanyExtrasOrderBy
  >;
  where?: InputMaybe<CompanyExtrasBoolExp>;
}>;

export type CountCompanyExtraQueryQuery = {
  readonly company_extras_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly body?: string | null;
      readonly category: string;
      readonly company_id?: string | null;
      readonly created_at: string;
      readonly found_count?: number | null;
      readonly id: number;
      readonly level: any;
      readonly review?: Record<string, any> | null;
      readonly success?: boolean | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
  };
};

export type FetchOneCompanyExtraQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCompanyExtraQueryQuery = {
  readonly company_extras_by_pk?: {
    readonly body?: string | null;
    readonly category: string;
    readonly company_id?: string | null;
    readonly created_at: string;
    readonly found_count?: number | null;
    readonly id: number;
    readonly level: any;
    readonly review?: Record<string, any> | null;
    readonly success?: boolean | null;
    readonly updated_at: string;
    readonly url: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type FetchManyCompanyMetricQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CompanyMetricsSelectColumn> | CompanyMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CompanyMetricsOrderBy> | CompanyMetricsOrderBy
  >;
  where?: InputMaybe<CompanyMetricsBoolExp>;
}>;

export type FetchManyCompanyMetricQueryQuery = {
  readonly company_metrics: ReadonlyArray<{
    readonly company_id: string;
    readonly crawl_id: string;
    readonly id: number;
    readonly metric_id?: number | null;
    readonly timestamp: string;
    readonly value: Record<string, any>;
    readonly metric_definition?: {
      readonly category?: string | null;
      readonly description?: string | null;
      readonly id: number;
      readonly is_dimensional?: boolean | null;
      readonly name: string;
      readonly type: string;
      readonly unit?: string | null;
    } | null;
  }>;
};

export type CountCompanyMetricQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CompanyMetricsSelectColumn> | CompanyMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CompanyMetricsOrderBy> | CompanyMetricsOrderBy
  >;
  where?: InputMaybe<CompanyMetricsBoolExp>;
}>;

export type CountCompanyMetricQueryQuery = {
  readonly company_metrics_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly company_id: string;
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
    }>;
  };
};

export type FetchOneCompanyMetricQueryVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneCompanyMetricQueryQuery = {
  readonly company_metrics_by_pk?: {
    readonly company_id: string;
    readonly crawl_id: string;
    readonly id: number;
    readonly metric_id?: number | null;
    readonly timestamp: string;
    readonly value: Record<string, any>;
    readonly metric_definition?: {
      readonly category?: string | null;
      readonly description?: string | null;
      readonly id: number;
      readonly is_dimensional?: boolean | null;
      readonly name: string;
      readonly type: string;
      readonly unit?: string | null;
    } | null;
  } | null;
};

export type FetchManyContactQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ContactsSelectColumn> | ContactsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContactsOrderBy> | ContactsOrderBy>;
  where?: InputMaybe<ContactsBoolExp>;
}>;

export type FetchManyContactQueryQuery = {
  readonly contacts: ReadonlyArray<{
    readonly company_id?: string | null;
    readonly contact_type?: any | null;
    readonly created_at?: string | null;
    readonly email?: string | null;
    readonly id: number;
    readonly is_primary?: boolean | null;
    readonly phone?: string | null;
    readonly privacy_level?: any | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly user_id?: string | null;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly company_contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_id: number;
      readonly created_at: string;
      readonly id: number;
      readonly updated_at: string;
    }>;
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  }>;
};

export type CountContactQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ContactsSelectColumn> | ContactsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContactsOrderBy> | ContactsOrderBy>;
  where?: InputMaybe<ContactsBoolExp>;
}>;

export type CountContactQueryQuery = {
  readonly contacts_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
  };
};

export type FetchOneContactQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneContactQueryQuery = {
  readonly contacts_by_pk?: {
    readonly company_id?: string | null;
    readonly contact_type?: any | null;
    readonly created_at?: string | null;
    readonly email?: string | null;
    readonly id: number;
    readonly is_primary?: boolean | null;
    readonly phone?: string | null;
    readonly privacy_level?: any | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly user_id?: string | null;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly company_contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_id: number;
      readonly created_at: string;
      readonly id: number;
      readonly updated_at: string;
    }>;
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type FetchManyContentCategoryQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ContentCategoriesSelectColumn> | ContentCategoriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ContentCategoriesOrderBy> | ContentCategoriesOrderBy
  >;
  where?: InputMaybe<ContentCategoriesBoolExp>;
}>;

export type FetchManyContentCategoryQueryQuery = {
  readonly content_categories: ReadonlyArray<{
    readonly category_id: number;
    readonly content_id: string;
    readonly is_primary: boolean;
    readonly category: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    };
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  }>;
};

export type CountContentCategoryQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ContentCategoriesSelectColumn> | ContentCategoriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ContentCategoriesOrderBy> | ContentCategoriesOrderBy
  >;
  where?: InputMaybe<ContentCategoriesBoolExp>;
}>;

export type CountContentCategoryQueryQuery = {
  readonly content_categories_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly category_id: number;
      readonly content_id: string;
      readonly is_primary: boolean;
    }>;
  };
};

export type FetchOneContentCategoryQueryVariables = Exact<{
  category_id: Scalars["bigint"]["input"];
  content_id: Scalars["uuid"]["input"];
}>;

export type FetchOneContentCategoryQueryQuery = {
  readonly content_categories_by_pk?: {
    readonly category_id: number;
    readonly content_id: string;
    readonly is_primary: boolean;
    readonly category: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    };
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type FetchManyContentScoreQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ContentScoresSelectColumn> | ContentScoresSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ContentScoresOrderBy> | ContentScoresOrderBy
  >;
  where?: InputMaybe<ContentScoresBoolExp>;
}>;

export type FetchManyContentScoreQueryQuery = {
  readonly content_scores: ReadonlyArray<{
    readonly categories?: Record<string, any> | null;
    readonly content_type?: any | null;
    readonly created_at?: string | null;
    readonly hot_score?: any | null;
    readonly id?: string | null;
    readonly status?: any | null;
    readonly tags?: Record<string, any> | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly url?: string | null;
  }>;
};

export type CountContentScoreQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ContentScoresSelectColumn> | ContentScoresSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ContentScoresOrderBy> | ContentScoresOrderBy
  >;
  where?: InputMaybe<ContentScoresBoolExp>;
}>;

export type CountContentScoreQueryQuery = {
  readonly content_scores_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly categories?: Record<string, any> | null;
      readonly content_type?: any | null;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id?: string | null;
      readonly status?: any | null;
      readonly tags?: Record<string, any> | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url?: string | null;
    }>;
  };
};

export type FetchManyContentSourceVisitQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<ContentSourceVisitsSelectColumn>
    | ContentSourceVisitsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ContentSourceVisitsOrderBy> | ContentSourceVisitsOrderBy
  >;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
}>;

export type FetchManyContentSourceVisitQueryQuery = {
  readonly content_source_visits: ReadonlyArray<{
    readonly content_id: string;
    readonly created_at?: string | null;
    readonly id: string;
    readonly user_id?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  }>;
};

export type CountContentSourceVisitQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<ContentSourceVisitsSelectColumn>
    | ContentSourceVisitsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ContentSourceVisitsOrderBy> | ContentSourceVisitsOrderBy
  >;
  where?: InputMaybe<ContentSourceVisitsBoolExp>;
}>;

export type CountContentSourceVisitQueryQuery = {
  readonly content_source_visits_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly content_id: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id?: string | null;
    }>;
  };
};

export type FetchOneContentSourceVisitQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneContentSourceVisitQueryQuery = {
  readonly content_source_visits_by_pk?: {
    readonly content_id: string;
    readonly created_at?: string | null;
    readonly id: string;
    readonly user_id?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type FetchManyContentSourceQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ContentSourcesSelectColumn> | ContentSourcesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ContentSourcesOrderBy> | ContentSourcesOrderBy
  >;
  where?: InputMaybe<ContentSourcesBoolExp>;
}>;

export type FetchManyContentSourceQueryQuery = {
  readonly content_sources: ReadonlyArray<{
    readonly company_id?: string | null;
    readonly content_type: any;
    readonly created_at?: string | null;
    readonly expected_count?: any | null;
    readonly failed_count?: any | null;
    readonly has_failed?: boolean | null;
    readonly hash?: number | null;
    readonly id: number;
    readonly priority: any;
    readonly refreshed_at?: string | null;
    readonly rss_urls?: ReadonlyArray<string> | null;
    readonly scrape_frequency: any;
    readonly scraped_at?: string | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly feed_sources: ReadonlyArray<{
      readonly content_source_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly news: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
  }>;
};

export type CountContentSourceQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ContentSourcesSelectColumn> | ContentSourcesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ContentSourcesOrderBy> | ContentSourcesOrderBy
  >;
  where?: InputMaybe<ContentSourcesBoolExp>;
}>;

export type CountContentSourceQueryQuery = {
  readonly content_sources_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
  };
};

export type FetchOneContentSourceQueryVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneContentSourceQueryQuery = {
  readonly content_sources_by_pk?: {
    readonly company_id?: string | null;
    readonly content_type: any;
    readonly created_at?: string | null;
    readonly expected_count?: any | null;
    readonly failed_count?: any | null;
    readonly has_failed?: boolean | null;
    readonly hash?: number | null;
    readonly id: number;
    readonly priority: any;
    readonly refreshed_at?: string | null;
    readonly rss_urls?: ReadonlyArray<string> | null;
    readonly scrape_frequency: any;
    readonly scraped_at?: string | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly feed_sources: ReadonlyArray<{
      readonly content_source_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly news: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
  } | null;
};

export type FetchManyContentStatusQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ContentStatusesSelectColumn> | ContentStatusesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ContentStatusesOrderBy> | ContentStatusesOrderBy
  >;
  where?: InputMaybe<ContentStatusesBoolExp>;
}>;

export type FetchManyContentStatusQueryQuery = {
  readonly content_statuses: ReadonlyArray<{
    readonly content_id: string;
    readonly content_status: any;
    readonly created_at?: string | null;
    readonly id: string;
    readonly notes?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  }>;
};

export type CountContentStatusQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ContentStatusesSelectColumn> | ContentStatusesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ContentStatusesOrderBy> | ContentStatusesOrderBy
  >;
  where?: InputMaybe<ContentStatusesBoolExp>;
}>;

export type CountContentStatusQueryQuery = {
  readonly content_statuses_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly content_id: string;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly notes?: string | null;
    }>;
  };
};

export type FetchOneContentStatusQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneContentStatusQueryQuery = {
  readonly content_statuses_by_pk?: {
    readonly content_id: string;
    readonly content_status: any;
    readonly created_at?: string | null;
    readonly id: string;
    readonly notes?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type FetchManyContentTagQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ContentTagsSelectColumn> | ContentTagsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentTagsOrderBy> | ContentTagsOrderBy>;
  where?: InputMaybe<ContentTagsBoolExp>;
}>;

export type FetchManyContentTagQueryQuery = {
  readonly content_tags: ReadonlyArray<{
    readonly content_id: string;
    readonly tag_id: number;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly tag: {
      readonly body?: string | null;
      readonly created_at?: string | null;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    };
  }>;
};

export type CountContentTagQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ContentTagsSelectColumn> | ContentTagsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentTagsOrderBy> | ContentTagsOrderBy>;
  where?: InputMaybe<ContentTagsBoolExp>;
}>;

export type CountContentTagQueryQuery = {
  readonly content_tags_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly content_id: string;
      readonly tag_id: number;
    }>;
  };
};

export type FetchOneContentTagQueryVariables = Exact<{
  content_id: Scalars["uuid"]["input"];
  tag_id: Scalars["Int"]["input"];
}>;

export type FetchOneContentTagQueryQuery = {
  readonly content_tags_by_pk?: {
    readonly content_id: string;
    readonly tag_id: number;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly tag: {
      readonly body?: string | null;
      readonly created_at?: string | null;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    };
  } | null;
};

export type FetchManyContentQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ContentsSelectColumn> | ContentsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentsOrderBy> | ContentsOrderBy>;
  where?: InputMaybe<ContentsBoolExp>;
}>;

export type FetchManyContentQueryQuery = {
  readonly contents: ReadonlyArray<{
    readonly content_type: any;
    readonly created_at?: string | null;
    readonly hot_score?: any | null;
    readonly id: string;
    readonly rss_url?: string | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly bookmarks: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly folder_id?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly content_categories: ReadonlyArray<{
      readonly category_id: number;
      readonly content_id: string;
      readonly is_primary: boolean;
    }>;
    readonly content_source_visits: ReadonlyArray<{
      readonly content_id: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id?: string | null;
    }>;
    readonly content_statuses: ReadonlyArray<{
      readonly content_id: string;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly notes?: string | null;
    }>;
    readonly content_tags: ReadonlyArray<{
      readonly content_id: string;
      readonly tag_id: number;
    }>;
    readonly news?: {
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    } | null;
    readonly newsletter?: {
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly frequency: string;
      readonly generated_content?: string | null;
      readonly id: string;
      readonly start_date: string;
      readonly title: string;
      readonly updated_at?: string | null;
    } | null;
    readonly research?: {
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
    } | null;
  }>;
};

export type CountContentQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ContentsSelectColumn> | ContentsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ContentsOrderBy> | ContentsOrderBy>;
  where?: InputMaybe<ContentsBoolExp>;
}>;

export type CountContentQueryQuery = {
  readonly contents_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
  };
};

export type FetchOneContentQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneContentQueryQuery = {
  readonly contents_by_pk?: {
    readonly content_type: any;
    readonly created_at?: string | null;
    readonly hot_score?: any | null;
    readonly id: string;
    readonly rss_url?: string | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly bookmarks: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly folder_id?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly content_categories: ReadonlyArray<{
      readonly category_id: number;
      readonly content_id: string;
      readonly is_primary: boolean;
    }>;
    readonly content_source_visits: ReadonlyArray<{
      readonly content_id: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id?: string | null;
    }>;
    readonly content_statuses: ReadonlyArray<{
      readonly content_id: string;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly notes?: string | null;
    }>;
    readonly content_tags: ReadonlyArray<{
      readonly content_id: string;
      readonly tag_id: number;
    }>;
    readonly news?: {
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    } | null;
    readonly newsletter?: {
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly frequency: string;
      readonly generated_content?: string | null;
      readonly id: string;
      readonly start_date: string;
      readonly title: string;
      readonly updated_at?: string | null;
    } | null;
    readonly research?: {
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
    } | null;
  } | null;
};

export type FetchManyCountryQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CountriesSelectColumn> | CountriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CountriesOrderBy> | CountriesOrderBy>;
  where?: InputMaybe<CountriesBoolExp>;
}>;

export type FetchManyCountryQueryQuery = {
  readonly countries: ReadonlyArray<{
    readonly code: string;
    readonly code_3?: string | null;
    readonly id: number;
    readonly name: string;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly cities: ReadonlyArray<{
      readonly country_id: number;
      readonly id: number;
      readonly name: string;
      readonly state?: string | null;
    }>;
  }>;
};

export type CountCountryQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CountriesSelectColumn> | CountriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<CountriesOrderBy> | CountriesOrderBy>;
  where?: InputMaybe<CountriesBoolExp>;
}>;

export type CountCountryQueryQuery = {
  readonly countries_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly code: string;
      readonly code_3?: string | null;
      readonly id: number;
      readonly name: string;
    }>;
  };
};

export type FetchOneCountryQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCountryQueryQuery = {
  readonly countries_by_pk?: {
    readonly code: string;
    readonly code_3?: string | null;
    readonly id: number;
    readonly name: string;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly cities: ReadonlyArray<{
      readonly country_id: number;
      readonly id: number;
      readonly name: string;
      readonly state?: string | null;
    }>;
  } | null;
};

export type FetchManyCustomerPaymentQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CustomerPaymentsSelectColumn> | CustomerPaymentsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CustomerPaymentsOrderBy> | CustomerPaymentsOrderBy
  >;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
}>;

export type FetchManyCustomerPaymentQueryQuery = {
  readonly customer_payments: ReadonlyArray<{
    readonly acquirer_data?: Record<string, any> | null;
    readonly amount: number;
    readonly amount_refunded?: number | null;
    readonly amount_transferred?: number | null;
    readonly bank?: string | null;
    readonly captured?: boolean | null;
    readonly created_at?: string | null;
    readonly currency: string;
    readonly description?: string | null;
    readonly error_code?: string | null;
    readonly error_description?: string | null;
    readonly error_reason?: string | null;
    readonly error_source?: string | null;
    readonly error_step?: string | null;
    readonly external_order_id?: string | null;
    readonly external_payment_id: string;
    readonly fee?: number | null;
    readonly id: number;
    readonly international?: boolean | null;
    readonly invoice_id?: string | null;
    readonly method?: string | null;
    readonly notes?: Record<string, any> | null;
    readonly order_id?: string | null;
    readonly payment_provider_id: number;
    readonly refund_status?: string | null;
    readonly status: string;
    readonly subscription_id?: number | null;
    readonly tax?: number | null;
    readonly user_id: string;
    readonly vpa?: string | null;
    readonly wallet?: string | null;
    readonly customer_refunds: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly batch_id?: string | null;
      readonly created_at?: string | null;
      readonly currency?: string | null;
      readonly external_refund_id: string;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly payment_id: number;
      readonly receipt?: string | null;
      readonly speed_processed?: string | null;
      readonly speed_requested?: string | null;
      readonly status: string;
    }>;
    readonly customer_subscription?: {
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    } | null;
    readonly payment_provider: {
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_active?: boolean | null;
      readonly name: string;
      readonly updated_at?: string | null;
    };
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  }>;
};

export type CountCustomerPaymentQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CustomerPaymentsSelectColumn> | CustomerPaymentsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CustomerPaymentsOrderBy> | CustomerPaymentsOrderBy
  >;
  where?: InputMaybe<CustomerPaymentsBoolExp>;
}>;

export type CountCustomerPaymentQueryQuery = {
  readonly customer_payments_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
  };
};

export type FetchOneCustomerPaymentQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCustomerPaymentQueryQuery = {
  readonly customer_payments_by_pk?: {
    readonly acquirer_data?: Record<string, any> | null;
    readonly amount: number;
    readonly amount_refunded?: number | null;
    readonly amount_transferred?: number | null;
    readonly bank?: string | null;
    readonly captured?: boolean | null;
    readonly created_at?: string | null;
    readonly currency: string;
    readonly description?: string | null;
    readonly error_code?: string | null;
    readonly error_description?: string | null;
    readonly error_reason?: string | null;
    readonly error_source?: string | null;
    readonly error_step?: string | null;
    readonly external_order_id?: string | null;
    readonly external_payment_id: string;
    readonly fee?: number | null;
    readonly id: number;
    readonly international?: boolean | null;
    readonly invoice_id?: string | null;
    readonly method?: string | null;
    readonly notes?: Record<string, any> | null;
    readonly order_id?: string | null;
    readonly payment_provider_id: number;
    readonly refund_status?: string | null;
    readonly status: string;
    readonly subscription_id?: number | null;
    readonly tax?: number | null;
    readonly user_id: string;
    readonly vpa?: string | null;
    readonly wallet?: string | null;
    readonly customer_refunds: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly batch_id?: string | null;
      readonly created_at?: string | null;
      readonly currency?: string | null;
      readonly external_refund_id: string;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly payment_id: number;
      readonly receipt?: string | null;
      readonly speed_processed?: string | null;
      readonly speed_requested?: string | null;
      readonly status: string;
    }>;
    readonly customer_subscription?: {
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    } | null;
    readonly payment_provider: {
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_active?: boolean | null;
      readonly name: string;
      readonly updated_at?: string | null;
    };
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type FetchManyCustomerProcessedWebhookQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<CustomerProcessedWebhooksSelectColumn>
    | CustomerProcessedWebhooksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    | ReadonlyArray<CustomerProcessedWebhooksOrderBy>
    | CustomerProcessedWebhooksOrderBy
  >;
  where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
}>;

export type FetchManyCustomerProcessedWebhookQueryQuery = {
  readonly customer_processed_webhooks: ReadonlyArray<{
    readonly event_id: string;
    readonly event_type: string;
    readonly id: number;
    readonly processed_at: string;
  }>;
};

export type CountCustomerProcessedWebhookQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<CustomerProcessedWebhooksSelectColumn>
    | CustomerProcessedWebhooksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    | ReadonlyArray<CustomerProcessedWebhooksOrderBy>
    | CustomerProcessedWebhooksOrderBy
  >;
  where?: InputMaybe<CustomerProcessedWebhooksBoolExp>;
}>;

export type CountCustomerProcessedWebhookQueryQuery = {
  readonly customer_processed_webhooks_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly event_id: string;
      readonly event_type: string;
      readonly id: number;
      readonly processed_at: string;
    }>;
  };
};

export type FetchOneCustomerProcessedWebhookQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCustomerProcessedWebhookQueryQuery = {
  readonly customer_processed_webhooks_by_pk?: {
    readonly event_id: string;
    readonly event_type: string;
    readonly id: number;
    readonly processed_at: string;
  } | null;
};

export type FetchManyCustomerRefundQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CustomerRefundsSelectColumn> | CustomerRefundsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CustomerRefundsOrderBy> | CustomerRefundsOrderBy
  >;
  where?: InputMaybe<CustomerRefundsBoolExp>;
}>;

export type FetchManyCustomerRefundQueryQuery = {
  readonly customer_refunds: ReadonlyArray<{
    readonly acquirer_data?: Record<string, any> | null;
    readonly amount: number;
    readonly batch_id?: string | null;
    readonly created_at?: string | null;
    readonly currency?: string | null;
    readonly external_refund_id: string;
    readonly id: number;
    readonly notes?: Record<string, any> | null;
    readonly payment_id: number;
    readonly receipt?: string | null;
    readonly speed_processed?: string | null;
    readonly speed_requested?: string | null;
    readonly status: string;
    readonly customer_payment: {
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    };
  }>;
};

export type CountCustomerRefundQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<CustomerRefundsSelectColumn> | CustomerRefundsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CustomerRefundsOrderBy> | CustomerRefundsOrderBy
  >;
  where?: InputMaybe<CustomerRefundsBoolExp>;
}>;

export type CountCustomerRefundQueryQuery = {
  readonly customer_refunds_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly batch_id?: string | null;
      readonly created_at?: string | null;
      readonly currency?: string | null;
      readonly external_refund_id: string;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly payment_id: number;
      readonly receipt?: string | null;
      readonly speed_processed?: string | null;
      readonly speed_requested?: string | null;
      readonly status: string;
    }>;
  };
};

export type FetchOneCustomerRefundQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCustomerRefundQueryQuery = {
  readonly customer_refunds_by_pk?: {
    readonly acquirer_data?: Record<string, any> | null;
    readonly amount: number;
    readonly batch_id?: string | null;
    readonly created_at?: string | null;
    readonly currency?: string | null;
    readonly external_refund_id: string;
    readonly id: number;
    readonly notes?: Record<string, any> | null;
    readonly payment_id: number;
    readonly receipt?: string | null;
    readonly speed_processed?: string | null;
    readonly speed_requested?: string | null;
    readonly status: string;
    readonly customer_payment: {
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    };
  } | null;
};

export type FetchManyCustomerSubscriptionPlanQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<CustomerSubscriptionPlansSelectColumn>
    | CustomerSubscriptionPlansSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    | ReadonlyArray<CustomerSubscriptionPlansOrderBy>
    | CustomerSubscriptionPlansOrderBy
  >;
  where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
}>;

export type FetchManyCustomerSubscriptionPlanQueryQuery = {
  readonly customer_subscription_plans: ReadonlyArray<{
    readonly annual_amount: number;
    readonly created_at?: string | null;
    readonly currency: string;
    readonly description?: string | null;
    readonly external_plan_id?: string | null;
    readonly features?: Record<string, any> | null;
    readonly id: number;
    readonly interval: number;
    readonly interval_type: string;
    readonly is_active?: boolean | null;
    readonly monthly_amount: number;
    readonly name: string;
    readonly updated_at?: string | null;
    readonly customer_subscriptions: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  }>;
};

export type CountCustomerSubscriptionPlanQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<CustomerSubscriptionPlansSelectColumn>
    | CustomerSubscriptionPlansSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    | ReadonlyArray<CustomerSubscriptionPlansOrderBy>
    | CustomerSubscriptionPlansOrderBy
  >;
  where?: InputMaybe<CustomerSubscriptionPlansBoolExp>;
}>;

export type CountCustomerSubscriptionPlanQueryQuery = {
  readonly customer_subscription_plans_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly annual_amount: number;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly external_plan_id?: string | null;
      readonly features?: Record<string, any> | null;
      readonly id: number;
      readonly interval: number;
      readonly interval_type: string;
      readonly is_active?: boolean | null;
      readonly monthly_amount: number;
      readonly name: string;
      readonly updated_at?: string | null;
    }>;
  };
};

export type FetchOneCustomerSubscriptionPlanQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCustomerSubscriptionPlanQueryQuery = {
  readonly customer_subscription_plans_by_pk?: {
    readonly annual_amount: number;
    readonly created_at?: string | null;
    readonly currency: string;
    readonly description?: string | null;
    readonly external_plan_id?: string | null;
    readonly features?: Record<string, any> | null;
    readonly id: number;
    readonly interval: number;
    readonly interval_type: string;
    readonly is_active?: boolean | null;
    readonly monthly_amount: number;
    readonly name: string;
    readonly updated_at?: string | null;
    readonly customer_subscriptions: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  } | null;
};

export type FetchManyCustomerSubscriptionQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<CustomerSubscriptionsSelectColumn>
    | CustomerSubscriptionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CustomerSubscriptionsOrderBy> | CustomerSubscriptionsOrderBy
  >;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
}>;

export type FetchManyCustomerSubscriptionQueryQuery = {
  readonly customer_subscriptions: ReadonlyArray<{
    readonly auth_attempts?: number | null;
    readonly cancel_at_period_end?: boolean | null;
    readonly cancel_initiated_by?: string | null;
    readonly change_scheduled_at?: string | null;
    readonly charge_at?: string | null;
    readonly created_at?: string | null;
    readonly current_end: string;
    readonly current_start: string;
    readonly customer_notify?: boolean | null;
    readonly end_at?: string | null;
    readonly ended_at?: string | null;
    readonly expire_by?: string | null;
    readonly external_subscription_id: string;
    readonly has_scheduled_changes?: boolean | null;
    readonly id: number;
    readonly notes?: Record<string, any> | null;
    readonly offer_id?: string | null;
    readonly paid_count?: number | null;
    readonly pause_initiated_by?: string | null;
    readonly payment_provider_id: number;
    readonly plan_id: number;
    readonly quantity?: number | null;
    readonly remaining_count?: number | null;
    readonly short_url?: string | null;
    readonly source?: string | null;
    readonly start_at?: string | null;
    readonly status: string;
    readonly total_count?: number | null;
    readonly type?: number | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly customer_payments: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
    readonly customer_subscription_plan: {
      readonly annual_amount: number;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly external_plan_id?: string | null;
      readonly features?: Record<string, any> | null;
      readonly id: number;
      readonly interval: number;
      readonly interval_type: string;
      readonly is_active?: boolean | null;
      readonly monthly_amount: number;
      readonly name: string;
      readonly updated_at?: string | null;
    };
    readonly payment_provider: {
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_active?: boolean | null;
      readonly name: string;
      readonly updated_at?: string | null;
    };
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  }>;
};

export type CountCustomerSubscriptionQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<CustomerSubscriptionsSelectColumn>
    | CustomerSubscriptionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<CustomerSubscriptionsOrderBy> | CustomerSubscriptionsOrderBy
  >;
  where?: InputMaybe<CustomerSubscriptionsBoolExp>;
}>;

export type CountCustomerSubscriptionQueryQuery = {
  readonly customer_subscriptions_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  };
};

export type FetchOneCustomerSubscriptionQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneCustomerSubscriptionQueryQuery = {
  readonly customer_subscriptions_by_pk?: {
    readonly auth_attempts?: number | null;
    readonly cancel_at_period_end?: boolean | null;
    readonly cancel_initiated_by?: string | null;
    readonly change_scheduled_at?: string | null;
    readonly charge_at?: string | null;
    readonly created_at?: string | null;
    readonly current_end: string;
    readonly current_start: string;
    readonly customer_notify?: boolean | null;
    readonly end_at?: string | null;
    readonly ended_at?: string | null;
    readonly expire_by?: string | null;
    readonly external_subscription_id: string;
    readonly has_scheduled_changes?: boolean | null;
    readonly id: number;
    readonly notes?: Record<string, any> | null;
    readonly offer_id?: string | null;
    readonly paid_count?: number | null;
    readonly pause_initiated_by?: string | null;
    readonly payment_provider_id: number;
    readonly plan_id: number;
    readonly quantity?: number | null;
    readonly remaining_count?: number | null;
    readonly short_url?: string | null;
    readonly source?: string | null;
    readonly start_at?: string | null;
    readonly status: string;
    readonly total_count?: number | null;
    readonly type?: number | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly customer_payments: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
    readonly customer_subscription_plan: {
      readonly annual_amount: number;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly external_plan_id?: string | null;
      readonly features?: Record<string, any> | null;
      readonly id: number;
      readonly interval: number;
      readonly interval_type: string;
      readonly is_active?: boolean | null;
      readonly monthly_amount: number;
      readonly name: string;
      readonly updated_at?: string | null;
    };
    readonly payment_provider: {
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_active?: boolean | null;
      readonly name: string;
      readonly updated_at?: string | null;
    };
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type FetchManyEmbeddingReviewQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<EmbeddingReviewsSelectColumn> | EmbeddingReviewsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<EmbeddingReviewsOrderBy> | EmbeddingReviewsOrderBy
  >;
  where?: InputMaybe<EmbeddingReviewsBoolExp>;
}>;

export type FetchManyEmbeddingReviewQueryQuery = {
  readonly embedding_reviews: ReadonlyArray<{
    readonly agent_review?: boolean | null;
    readonly created_at: string;
    readonly human_review?: boolean | null;
    readonly id: number;
    readonly notes?: string | null;
    readonly updated_at?: string | null;
    readonly research_embeddings: ReadonlyArray<{
      readonly chunk: string;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly embedding_review_id?: number | null;
      readonly id: number;
      readonly is_flagged?: boolean | null;
      readonly research_id: string;
      readonly updated_at: string;
      readonly url?: string | null;
    }>;
  }>;
};

export type CountEmbeddingReviewQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<EmbeddingReviewsSelectColumn> | EmbeddingReviewsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<EmbeddingReviewsOrderBy> | EmbeddingReviewsOrderBy
  >;
  where?: InputMaybe<EmbeddingReviewsBoolExp>;
}>;

export type CountEmbeddingReviewQueryQuery = {
  readonly embedding_reviews_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly agent_review?: boolean | null;
      readonly created_at: string;
      readonly human_review?: boolean | null;
      readonly id: number;
      readonly notes?: string | null;
      readonly updated_at?: string | null;
    }>;
  };
};

export type FetchOneEmbeddingReviewQueryVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneEmbeddingReviewQueryQuery = {
  readonly embedding_reviews_by_pk?: {
    readonly agent_review?: boolean | null;
    readonly created_at: string;
    readonly human_review?: boolean | null;
    readonly id: number;
    readonly notes?: string | null;
    readonly updated_at?: string | null;
    readonly research_embeddings: ReadonlyArray<{
      readonly chunk: string;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly embedding_review_id?: number | null;
      readonly id: number;
      readonly is_flagged?: boolean | null;
      readonly research_id: string;
      readonly updated_at: string;
      readonly url?: string | null;
    }>;
  } | null;
};

export type FetchManyErrorCorrelationQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ErrorCorrelationsSelectColumn> | ErrorCorrelationsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ErrorCorrelationsOrderBy> | ErrorCorrelationsOrderBy
  >;
  where?: InputMaybe<ErrorCorrelationsBoolExp>;
}>;

export type FetchManyErrorCorrelationQueryQuery = {
  readonly error_correlations: ReadonlyArray<{
    readonly avg_time_difference?: number | null;
    readonly correlation_count?: number | null;
    readonly id?: number | null;
    readonly source_pattern?: string | null;
    readonly source_service?: string | null;
    readonly target_pattern?: string | null;
    readonly target_service?: string | null;
  }>;
};

export type CountErrorCorrelationQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ErrorCorrelationsSelectColumn> | ErrorCorrelationsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ErrorCorrelationsOrderBy> | ErrorCorrelationsOrderBy
  >;
  where?: InputMaybe<ErrorCorrelationsBoolExp>;
}>;

export type CountErrorCorrelationQueryQuery = {
  readonly error_correlations_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly avg_time_difference?: number | null;
      readonly correlation_count?: number | null;
      readonly id?: number | null;
      readonly source_pattern?: string | null;
      readonly source_service?: string | null;
      readonly target_pattern?: string | null;
      readonly target_service?: string | null;
    }>;
  };
};

export type FetchManyErrorFrequencyQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ErrorFrequencySelectColumn> | ErrorFrequencySelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ErrorFrequencyOrderBy> | ErrorFrequencyOrderBy
  >;
  where?: InputMaybe<ErrorFrequencyBoolExp>;
}>;

export type FetchManyErrorFrequencyQueryQuery = {
  readonly error_frequency: ReadonlyArray<{
    readonly error_count?: number | null;
    readonly error_type?: any | null;
    readonly service_name?: string | null;
    readonly severity?: any | null;
    readonly time_bucket?: string | null;
  }>;
};

export type CountErrorFrequencyQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ErrorFrequencySelectColumn> | ErrorFrequencySelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ErrorFrequencyOrderBy> | ErrorFrequencyOrderBy
  >;
  where?: InputMaybe<ErrorFrequencyBoolExp>;
}>;

export type CountErrorFrequencyQueryQuery = {
  readonly error_frequency_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly error_count?: number | null;
      readonly error_type?: any | null;
      readonly service_name?: string | null;
      readonly severity?: any | null;
      readonly time_bucket?: string | null;
    }>;
  };
};

export type FetchManyErrorLogQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ErrorLogsSelectColumn> | ErrorLogsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorLogsOrderBy> | ErrorLogsOrderBy>;
  where?: InputMaybe<ErrorLogsBoolExp>;
}>;

export type FetchManyErrorLogQueryQuery = {
  readonly error_logs: ReadonlyArray<{
    readonly context?: Record<string, any> | null;
    readonly correlation_id?: string | null;
    readonly created_at?: string | null;
    readonly domain?: string | null;
    readonly environment: string;
    readonly error_hash?: string | null;
    readonly error_pattern?: string | null;
    readonly error_type: any;
    readonly frequency_data?: Record<string, any> | null;
    readonly github_repo?: string | null;
    readonly id: string;
    readonly is_new_pattern?: boolean | null;
    readonly message: string;
    readonly metadata?: Record<string, any> | null;
    readonly related_errors?: Record<string, any> | null;
    readonly request_id?: string | null;
    readonly service_name: string;
    readonly severity: any;
    readonly stack_trace?: string | null;
    readonly user_id?: string | null;
  }>;
};

export type CountErrorLogQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ErrorLogsSelectColumn> | ErrorLogsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorLogsOrderBy> | ErrorLogsOrderBy>;
  where?: InputMaybe<ErrorLogsBoolExp>;
}>;

export type CountErrorLogQueryQuery = {
  readonly error_logs_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly context?: Record<string, any> | null;
      readonly correlation_id?: string | null;
      readonly created_at?: string | null;
      readonly domain?: string | null;
      readonly environment: string;
      readonly error_hash?: string | null;
      readonly error_pattern?: string | null;
      readonly error_type: any;
      readonly frequency_data?: Record<string, any> | null;
      readonly github_repo?: string | null;
      readonly id: string;
      readonly is_new_pattern?: boolean | null;
      readonly message: string;
      readonly metadata?: Record<string, any> | null;
      readonly related_errors?: Record<string, any> | null;
      readonly request_id?: string | null;
      readonly service_name: string;
      readonly severity: any;
      readonly stack_trace?: string | null;
      readonly user_id?: string | null;
    }>;
  };
};

export type FetchOneErrorLogQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneErrorLogQueryQuery = {
  readonly error_logs_by_pk?: {
    readonly context?: Record<string, any> | null;
    readonly correlation_id?: string | null;
    readonly created_at?: string | null;
    readonly domain?: string | null;
    readonly environment: string;
    readonly error_hash?: string | null;
    readonly error_pattern?: string | null;
    readonly error_type: any;
    readonly frequency_data?: Record<string, any> | null;
    readonly github_repo?: string | null;
    readonly id: string;
    readonly is_new_pattern?: boolean | null;
    readonly message: string;
    readonly metadata?: Record<string, any> | null;
    readonly related_errors?: Record<string, any> | null;
    readonly request_id?: string | null;
    readonly service_name: string;
    readonly severity: any;
    readonly stack_trace?: string | null;
    readonly user_id?: string | null;
  } | null;
};

export type FetchManyErrorMetricQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ErrorMetricsSelectColumn> | ErrorMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ErrorMetricsOrderBy> | ErrorMetricsOrderBy
  >;
  where?: InputMaybe<ErrorMetricsBoolExp>;
}>;

export type FetchManyErrorMetricQueryQuery = {
  readonly error_metrics: ReadonlyArray<{
    readonly error_count?: number | null;
    readonly error_type?: any | null;
    readonly service_name?: string | null;
    readonly severity?: any | null;
    readonly time_bucket?: string | null;
  }>;
};

export type CountErrorMetricQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ErrorMetricsSelectColumn> | ErrorMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ErrorMetricsOrderBy> | ErrorMetricsOrderBy
  >;
  where?: InputMaybe<ErrorMetricsBoolExp>;
}>;

export type CountErrorMetricQueryQuery = {
  readonly error_metrics_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly error_count?: number | null;
      readonly error_type?: any | null;
      readonly service_name?: string | null;
      readonly severity?: any | null;
      readonly time_bucket?: string | null;
    }>;
  };
};

export type FetchManyErrorPatternQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ErrorPatternsSelectColumn> | ErrorPatternsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ErrorPatternsOrderBy> | ErrorPatternsOrderBy
  >;
  where?: InputMaybe<ErrorPatternsBoolExp>;
}>;

export type FetchManyErrorPatternQueryQuery = {
  readonly error_patterns: ReadonlyArray<{
    readonly contexts?: Record<string, any> | null;
    readonly daily_frequency?: any | null;
    readonly days_active?: number | null;
    readonly error_hash?: string | null;
    readonly error_pattern?: string | null;
    readonly first_seen?: string | null;
    readonly id?: number | null;
    readonly is_new?: boolean | null;
    readonly last_seen?: string | null;
    readonly occurrence_count?: number | null;
    readonly service_name?: string | null;
    readonly severity_levels?: ReadonlyArray<any> | null;
  }>;
};

export type CountErrorPatternQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ErrorPatternsSelectColumn> | ErrorPatternsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ErrorPatternsOrderBy> | ErrorPatternsOrderBy
  >;
  where?: InputMaybe<ErrorPatternsBoolExp>;
}>;

export type CountErrorPatternQueryQuery = {
  readonly error_patterns_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly contexts?: Record<string, any> | null;
      readonly daily_frequency?: any | null;
      readonly days_active?: number | null;
      readonly error_hash?: string | null;
      readonly error_pattern?: string | null;
      readonly first_seen?: string | null;
      readonly id?: number | null;
      readonly is_new?: boolean | null;
      readonly last_seen?: string | null;
      readonly occurrence_count?: number | null;
      readonly service_name?: string | null;
      readonly severity_levels?: ReadonlyArray<any> | null;
    }>;
  };
};

export type FetchManyErrorStatQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ErrorStatsSelectColumn> | ErrorStatsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorStatsOrderBy> | ErrorStatsOrderBy>;
  where?: InputMaybe<ErrorStatsBoolExp>;
}>;

export type FetchManyErrorStatQueryQuery = {
  readonly error_stats: ReadonlyArray<{
    readonly calls?: number | null;
    readonly max_exec_time?: any | null;
    readonly mean_exec_time?: any | null;
    readonly query?: string | null;
    readonly queryid?: number | null;
    readonly rows?: number | null;
    readonly toplevel?: boolean | null;
  }>;
};

export type CountErrorStatQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ErrorStatsSelectColumn> | ErrorStatsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ErrorStatsOrderBy> | ErrorStatsOrderBy>;
  where?: InputMaybe<ErrorStatsBoolExp>;
}>;

export type CountErrorStatQueryQuery = {
  readonly error_stats_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly calls?: number | null;
      readonly max_exec_time?: any | null;
      readonly mean_exec_time?: any | null;
      readonly query?: string | null;
      readonly queryid?: number | null;
      readonly rows?: number | null;
      readonly toplevel?: boolean | null;
    }>;
  };
};

export type FetchManyFeatureRequestQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<FeatureRequestsSelectColumn> | FeatureRequestsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<FeatureRequestsOrderBy> | FeatureRequestsOrderBy
  >;
  where?: InputMaybe<FeatureRequestsBoolExp>;
}>;

export type FetchManyFeatureRequestQueryQuery = {
  readonly feature_requests: ReadonlyArray<{
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly downvotes?: number | null;
    readonly engagement_score?: number | null;
    readonly id: string;
    readonly priority_score?: number | null;
    readonly status: string;
    readonly title: string;
    readonly updated_at?: string | null;
    readonly upvotes?: number | null;
    readonly feature_votes: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly feature_id: string;
      readonly feedback?: string | null;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly vote_type: any;
    }>;
  }>;
};

export type CountFeatureRequestQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<FeatureRequestsSelectColumn> | FeatureRequestsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<FeatureRequestsOrderBy> | FeatureRequestsOrderBy
  >;
  where?: InputMaybe<FeatureRequestsBoolExp>;
}>;

export type CountFeatureRequestQueryQuery = {
  readonly feature_requests_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly downvotes?: number | null;
      readonly engagement_score?: number | null;
      readonly id: string;
      readonly priority_score?: number | null;
      readonly status: string;
      readonly title: string;
      readonly updated_at?: string | null;
      readonly upvotes?: number | null;
    }>;
  };
};

export type FetchOneFeatureRequestQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneFeatureRequestQueryQuery = {
  readonly feature_requests_by_pk?: {
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly downvotes?: number | null;
    readonly engagement_score?: number | null;
    readonly id: string;
    readonly priority_score?: number | null;
    readonly status: string;
    readonly title: string;
    readonly updated_at?: string | null;
    readonly upvotes?: number | null;
    readonly feature_votes: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly feature_id: string;
      readonly feedback?: string | null;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly vote_type: any;
    }>;
  } | null;
};

export type FetchManyFeatureVoteQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<FeatureVotesSelectColumn> | FeatureVotesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<FeatureVotesOrderBy> | FeatureVotesOrderBy
  >;
  where?: InputMaybe<FeatureVotesBoolExp>;
}>;

export type FetchManyFeatureVoteQueryQuery = {
  readonly feature_votes: ReadonlyArray<{
    readonly created_at?: string | null;
    readonly feature_id: string;
    readonly feedback?: string | null;
    readonly id: string;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly vote_type: any;
    readonly feature_request: {
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly downvotes?: number | null;
      readonly engagement_score?: number | null;
      readonly id: string;
      readonly priority_score?: number | null;
      readonly status: string;
      readonly title: string;
      readonly updated_at?: string | null;
      readonly upvotes?: number | null;
    };
  }>;
};

export type CountFeatureVoteQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<FeatureVotesSelectColumn> | FeatureVotesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<FeatureVotesOrderBy> | FeatureVotesOrderBy
  >;
  where?: InputMaybe<FeatureVotesBoolExp>;
}>;

export type CountFeatureVoteQueryQuery = {
  readonly feature_votes_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly feature_id: string;
      readonly feedback?: string | null;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly vote_type: any;
    }>;
  };
};

export type FetchOneFeatureVoteQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneFeatureVoteQueryQuery = {
  readonly feature_votes_by_pk?: {
    readonly created_at?: string | null;
    readonly feature_id: string;
    readonly feedback?: string | null;
    readonly id: string;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly vote_type: any;
    readonly feature_request: {
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly downvotes?: number | null;
      readonly engagement_score?: number | null;
      readonly id: string;
      readonly priority_score?: number | null;
      readonly status: string;
      readonly title: string;
      readonly updated_at?: string | null;
      readonly upvotes?: number | null;
    };
  } | null;
};

export type FetchManyFeedCategoryQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<FeedCategoriesSelectColumn> | FeedCategoriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<FeedCategoriesOrderBy> | FeedCategoriesOrderBy
  >;
  where?: InputMaybe<FeedCategoriesBoolExp>;
}>;

export type FetchManyFeedCategoryQueryQuery = {
  readonly feed_categories: ReadonlyArray<{
    readonly category_id?: number | null;
    readonly created_at: string;
    readonly feed_id?: string | null;
    readonly id: number;
    readonly category?: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly feed?: {
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    } | null;
  }>;
};

export type CountFeedCategoryQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<FeedCategoriesSelectColumn> | FeedCategoriesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<FeedCategoriesOrderBy> | FeedCategoriesOrderBy
  >;
  where?: InputMaybe<FeedCategoriesBoolExp>;
}>;

export type CountFeedCategoryQueryQuery = {
  readonly feed_categories_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly category_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
  };
};

export type FetchOneFeedCategoryQueryVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneFeedCategoryQueryQuery = {
  readonly feed_categories_by_pk?: {
    readonly category_id?: number | null;
    readonly created_at: string;
    readonly feed_id?: string | null;
    readonly id: number;
    readonly category?: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly feed?: {
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    } | null;
  } | null;
};

export type FetchManyFeedSourceQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<FeedSourcesSelectColumn> | FeedSourcesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedSourcesOrderBy> | FeedSourcesOrderBy>;
  where?: InputMaybe<FeedSourcesBoolExp>;
}>;

export type FetchManyFeedSourceQueryQuery = {
  readonly feed_sources: ReadonlyArray<{
    readonly content_source_id?: number | null;
    readonly created_at: string;
    readonly feed_id?: string | null;
    readonly id: number;
    readonly content_source?: {
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly feed?: {
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    } | null;
  }>;
};

export type CountFeedSourceQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<FeedSourcesSelectColumn> | FeedSourcesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedSourcesOrderBy> | FeedSourcesOrderBy>;
  where?: InputMaybe<FeedSourcesBoolExp>;
}>;

export type CountFeedSourceQueryQuery = {
  readonly feed_sources_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly content_source_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
  };
};

export type FetchOneFeedSourceQueryVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneFeedSourceQueryQuery = {
  readonly feed_sources_by_pk?: {
    readonly content_source_id?: number | null;
    readonly created_at: string;
    readonly feed_id?: string | null;
    readonly id: number;
    readonly content_source?: {
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly feed?: {
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    } | null;
  } | null;
};

export type FetchManyFeedbackQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<FeedbacksSelectColumn> | FeedbacksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedbacksOrderBy> | FeedbacksOrderBy>;
  where?: InputMaybe<FeedbacksBoolExp>;
}>;

export type FetchManyFeedbackQueryQuery = {
  readonly feedbacks: ReadonlyArray<{
    readonly created_at: string;
    readonly device_info?: string | null;
    readonly feedback_status?: any | null;
    readonly feedback_type?: any | null;
    readonly id: number;
    readonly message: string;
    readonly page_identifier: string;
    readonly rating?: number | null;
    readonly resolution_comment?: string | null;
    readonly updated_at: string;
    readonly user_id?: string | null;
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  }>;
};

export type CountFeedbackQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<FeedbacksSelectColumn> | FeedbacksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedbacksOrderBy> | FeedbacksOrderBy>;
  where?: InputMaybe<FeedbacksBoolExp>;
}>;

export type CountFeedbackQueryQuery = {
  readonly feedbacks_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly created_at: string;
      readonly device_info?: string | null;
      readonly feedback_status?: any | null;
      readonly feedback_type?: any | null;
      readonly id: number;
      readonly message: string;
      readonly page_identifier: string;
      readonly rating?: number | null;
      readonly resolution_comment?: string | null;
      readonly updated_at: string;
      readonly user_id?: string | null;
    }>;
  };
};

export type FetchOneFeedbackQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneFeedbackQueryQuery = {
  readonly feedbacks_by_pk?: {
    readonly created_at: string;
    readonly device_info?: string | null;
    readonly feedback_status?: any | null;
    readonly feedback_type?: any | null;
    readonly id: number;
    readonly message: string;
    readonly page_identifier: string;
    readonly rating?: number | null;
    readonly resolution_comment?: string | null;
    readonly updated_at: string;
    readonly user_id?: string | null;
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type FetchManyFeedQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<FeedsSelectColumn> | FeedsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedsOrderBy> | FeedsOrderBy>;
  where?: InputMaybe<FeedsBoolExp>;
}>;

export type FetchManyFeedQueryQuery = {
  readonly feeds: ReadonlyArray<{
    readonly created_at: string;
    readonly id: string;
    readonly name?: string | null;
    readonly user_id?: string | null;
    readonly feed_categories: ReadonlyArray<{
      readonly category_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly feed_sources: ReadonlyArray<{
      readonly content_source_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  }>;
};

export type CountFeedQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<FeedsSelectColumn> | FeedsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FeedsOrderBy> | FeedsOrderBy>;
  where?: InputMaybe<FeedsBoolExp>;
}>;

export type CountFeedQueryQuery = {
  readonly feeds_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    }>;
  };
};

export type FetchOneFeedQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneFeedQueryQuery = {
  readonly feeds_by_pk?: {
    readonly created_at: string;
    readonly id: string;
    readonly name?: string | null;
    readonly user_id?: string | null;
    readonly feed_categories: ReadonlyArray<{
      readonly category_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly feed_sources: ReadonlyArray<{
      readonly content_source_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type FetchManyFollowQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<FollowsSelectColumn> | FollowsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FollowsOrderBy> | FollowsOrderBy>;
  where?: InputMaybe<FollowsBoolExp>;
}>;

export type FetchManyFollowQueryQuery = {
  readonly follows: ReadonlyArray<{
    readonly created_at?: string | null;
    readonly followed_entity: any;
    readonly followed_id: string;
    readonly id: string;
    readonly user_id: string;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  }>;
};

export type CountFollowQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<FollowsSelectColumn> | FollowsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<FollowsOrderBy> | FollowsOrderBy>;
  where?: InputMaybe<FollowsBoolExp>;
}>;

export type CountFollowQueryQuery = {
  readonly follows_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly followed_entity: any;
      readonly followed_id: string;
      readonly id: string;
      readonly user_id: string;
    }>;
  };
};

export type FetchOneFollowQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneFollowQueryQuery = {
  readonly follows_by_pk?: {
    readonly created_at?: string | null;
    readonly followed_entity: any;
    readonly followed_id: string;
    readonly id: string;
    readonly user_id: string;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type FetchManyMetricDefinitionQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<MetricDefinitionsSelectColumn> | MetricDefinitionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<MetricDefinitionsOrderBy> | MetricDefinitionsOrderBy
  >;
  where?: InputMaybe<MetricDefinitionsBoolExp>;
}>;

export type FetchManyMetricDefinitionQueryQuery = {
  readonly metric_definitions: ReadonlyArray<{
    readonly category?: string | null;
    readonly description?: string | null;
    readonly id: number;
    readonly is_dimensional?: boolean | null;
    readonly name: string;
    readonly type: string;
    readonly unit?: string | null;
    readonly company_metrics: ReadonlyArray<{
      readonly company_id: string;
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
    }>;
    readonly spider_metrics: ReadonlyArray<{
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
    }>;
  }>;
};

export type CountMetricDefinitionQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<MetricDefinitionsSelectColumn> | MetricDefinitionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<MetricDefinitionsOrderBy> | MetricDefinitionsOrderBy
  >;
  where?: InputMaybe<MetricDefinitionsBoolExp>;
}>;

export type CountMetricDefinitionQueryQuery = {
  readonly metric_definitions_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly category?: string | null;
      readonly description?: string | null;
      readonly id: number;
      readonly is_dimensional?: boolean | null;
      readonly name: string;
      readonly type: string;
      readonly unit?: string | null;
    }>;
  };
};

export type FetchOneMetricDefinitionQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneMetricDefinitionQueryQuery = {
  readonly metric_definitions_by_pk?: {
    readonly category?: string | null;
    readonly description?: string | null;
    readonly id: number;
    readonly is_dimensional?: boolean | null;
    readonly name: string;
    readonly type: string;
    readonly unit?: string | null;
    readonly company_metrics: ReadonlyArray<{
      readonly company_id: string;
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
    }>;
    readonly spider_metrics: ReadonlyArray<{
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
    }>;
  } | null;
};

export type FetchManyNewsQueryVariables = Exact<{
  distinct_on?: InputMaybe<ReadonlyArray<NewsSelectColumn> | NewsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsOrderBy> | NewsOrderBy>;
  where?: InputMaybe<NewsBoolExp>;
}>;

export type FetchManyNewsQueryQuery = {
  readonly news: ReadonlyArray<{
    readonly author?: string | null;
    readonly body?: string | null;
    readonly category_id?: number | null;
    readonly company_id?: string | null;
    readonly content_source_id?: number | null;
    readonly content_status: any;
    readonly created_at: string;
    readonly description?: string | null;
    readonly failed_count?: any | null;
    readonly featured_image?: string | null;
    readonly has_summary: boolean;
    readonly hash?: number | null;
    readonly id: string;
    readonly keywords?: Record<string, any> | null;
    readonly published_at?: string | null;
    readonly scrape_frequency: any;
    readonly scraped_at?: string | null;
    readonly title?: string | null;
    readonly updated_at: string;
    readonly url: string;
    readonly category?: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly content_source?: {
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly news_summaries: ReadonlyArray<{
      readonly complexity_level?: any | null;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: string;
      readonly is_current?: boolean | null;
      readonly news_id: string;
      readonly summary?: string | null;
      readonly updated_at?: string | null;
      readonly version: number;
    }>;
  }>;
};

export type CountNewsQueryVariables = Exact<{
  distinct_on?: InputMaybe<ReadonlyArray<NewsSelectColumn> | NewsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsOrderBy> | NewsOrderBy>;
  where?: InputMaybe<NewsBoolExp>;
}>;

export type CountNewsQueryQuery = {
  readonly news_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
  };
};

export type FetchOneNewsQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneNewsQueryQuery = {
  readonly news_by_pk?: {
    readonly author?: string | null;
    readonly body?: string | null;
    readonly category_id?: number | null;
    readonly company_id?: string | null;
    readonly content_source_id?: number | null;
    readonly content_status: any;
    readonly created_at: string;
    readonly description?: string | null;
    readonly failed_count?: any | null;
    readonly featured_image?: string | null;
    readonly has_summary: boolean;
    readonly hash?: number | null;
    readonly id: string;
    readonly keywords?: Record<string, any> | null;
    readonly published_at?: string | null;
    readonly scrape_frequency: any;
    readonly scraped_at?: string | null;
    readonly title?: string | null;
    readonly updated_at: string;
    readonly url: string;
    readonly category?: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly content_source?: {
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly news_summaries: ReadonlyArray<{
      readonly complexity_level?: any | null;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: string;
      readonly is_current?: boolean | null;
      readonly news_id: string;
      readonly summary?: string | null;
      readonly updated_at?: string | null;
      readonly version: number;
    }>;
  } | null;
};

export type FetchManyNewsDetailQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<NewsDetailsSelectColumn> | NewsDetailsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsDetailsOrderBy> | NewsDetailsOrderBy>;
  where?: InputMaybe<NewsDetailsBoolExp>;
}>;

export type FetchManyNewsDetailQueryQuery = {
  readonly news_details: ReadonlyArray<{
    readonly author?: string | null;
    readonly bookmark_count?: number | null;
    readonly categories?: Record<string, any> | null;
    readonly company_logo?: string | null;
    readonly company_name?: string | null;
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly featured_image?: string | null;
    readonly hot_score?: any | null;
    readonly id?: string | null;
    readonly published_at?: string | null;
    readonly summaries?: Record<string, any> | null;
    readonly tags?: Record<string, any> | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly url?: string | null;
    readonly vote_count?: number | null;
  }>;
};

export type CountNewsDetailQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<NewsDetailsSelectColumn> | NewsDetailsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsDetailsOrderBy> | NewsDetailsOrderBy>;
  where?: InputMaybe<NewsDetailsBoolExp>;
}>;

export type CountNewsDetailQueryQuery = {
  readonly news_details_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly author?: string | null;
      readonly bookmark_count?: number | null;
      readonly categories?: Record<string, any> | null;
      readonly company_logo?: string | null;
      readonly company_name?: string | null;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly featured_image?: string | null;
      readonly hot_score?: any | null;
      readonly id?: string | null;
      readonly published_at?: string | null;
      readonly summaries?: Record<string, any> | null;
      readonly tags?: Record<string, any> | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url?: string | null;
      readonly vote_count?: number | null;
    }>;
  };
};

export type FetchManyNewsSummaryQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<NewsSummariesSelectColumn> | NewsSummariesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<NewsSummariesOrderBy> | NewsSummariesOrderBy
  >;
  where?: InputMaybe<NewsSummariesBoolExp>;
}>;

export type FetchManyNewsSummaryQueryQuery = {
  readonly news_summaries: ReadonlyArray<{
    readonly complexity_level?: any | null;
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly id: string;
    readonly is_current?: boolean | null;
    readonly news_id: string;
    readonly summary?: string | null;
    readonly updated_at?: string | null;
    readonly version: number;
    readonly news: {
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    };
  }>;
};

export type CountNewsSummaryQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<NewsSummariesSelectColumn> | NewsSummariesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<NewsSummariesOrderBy> | NewsSummariesOrderBy
  >;
  where?: InputMaybe<NewsSummariesBoolExp>;
}>;

export type CountNewsSummaryQueryQuery = {
  readonly news_summaries_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly complexity_level?: any | null;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: string;
      readonly is_current?: boolean | null;
      readonly news_id: string;
      readonly summary?: string | null;
      readonly updated_at?: string | null;
      readonly version: number;
    }>;
  };
};

export type FetchOneNewsSummaryQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneNewsSummaryQueryQuery = {
  readonly news_summaries_by_pk?: {
    readonly complexity_level?: any | null;
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly id: string;
    readonly is_current?: boolean | null;
    readonly news_id: string;
    readonly summary?: string | null;
    readonly updated_at?: string | null;
    readonly version: number;
    readonly news: {
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    };
  } | null;
};

export type FetchManyNewsTagQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<NewsTagsSelectColumn> | NewsTagsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsTagsOrderBy> | NewsTagsOrderBy>;
  where?: InputMaybe<NewsTagsBoolExp>;
}>;

export type FetchManyNewsTagQueryQuery = {
  readonly news_tags: ReadonlyArray<{
    readonly id: number;
    readonly news_id?: string | null;
    readonly tag_id: number;
    readonly tag: {
      readonly body?: string | null;
      readonly created_at?: string | null;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    };
  }>;
};

export type CountNewsTagQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<NewsTagsSelectColumn> | NewsTagsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewsTagsOrderBy> | NewsTagsOrderBy>;
  where?: InputMaybe<NewsTagsBoolExp>;
}>;

export type CountNewsTagQueryQuery = {
  readonly news_tags_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly id: number;
      readonly news_id?: string | null;
      readonly tag_id: number;
    }>;
  };
};

export type FetchOneNewsTagQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneNewsTagQueryQuery = {
  readonly news_tags_by_pk?: {
    readonly id: number;
    readonly news_id?: string | null;
    readonly tag_id: number;
    readonly tag: {
      readonly body?: string | null;
      readonly created_at?: string | null;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    };
  } | null;
};

export type FetchManyNewsletterQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<NewslettersSelectColumn> | NewslettersSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewslettersOrderBy> | NewslettersOrderBy>;
  where?: InputMaybe<NewslettersBoolExp>;
}>;

export type FetchManyNewsletterQueryQuery = {
  readonly newsletters: ReadonlyArray<{
    readonly content_status: any;
    readonly created_at?: string | null;
    readonly end_date: string;
    readonly frequency: string;
    readonly generated_content?: string | null;
    readonly id: string;
    readonly start_date: string;
    readonly title: string;
    readonly updated_at?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  }>;
};

export type CountNewsletterQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<NewslettersSelectColumn> | NewslettersSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<NewslettersOrderBy> | NewslettersOrderBy>;
  where?: InputMaybe<NewslettersBoolExp>;
}>;

export type CountNewsletterQueryQuery = {
  readonly newsletters_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly frequency: string;
      readonly generated_content?: string | null;
      readonly id: string;
      readonly start_date: string;
      readonly title: string;
      readonly updated_at?: string | null;
    }>;
  };
};

export type FetchOneNewsletterQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneNewsletterQueryQuery = {
  readonly newsletters_by_pk?: {
    readonly content_status: any;
    readonly created_at?: string | null;
    readonly end_date: string;
    readonly frequency: string;
    readonly generated_content?: string | null;
    readonly id: string;
    readonly start_date: string;
    readonly title: string;
    readonly updated_at?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type FetchManyPaymentProviderQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<PaymentProvidersSelectColumn> | PaymentProvidersSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<PaymentProvidersOrderBy> | PaymentProvidersOrderBy
  >;
  where?: InputMaybe<PaymentProvidersBoolExp>;
}>;

export type FetchManyPaymentProviderQueryQuery = {
  readonly payment_providers: ReadonlyArray<{
    readonly created_at?: string | null;
    readonly id: number;
    readonly is_active?: boolean | null;
    readonly name: string;
    readonly updated_at?: string | null;
    readonly customer_payments: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
    readonly customer_subscriptions: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  }>;
};

export type CountPaymentProviderQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<PaymentProvidersSelectColumn> | PaymentProvidersSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<PaymentProvidersOrderBy> | PaymentProvidersOrderBy
  >;
  where?: InputMaybe<PaymentProvidersBoolExp>;
}>;

export type CountPaymentProviderQueryQuery = {
  readonly payment_providers_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_active?: boolean | null;
      readonly name: string;
      readonly updated_at?: string | null;
    }>;
  };
};

export type FetchOnePaymentProviderQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOnePaymentProviderQueryQuery = {
  readonly payment_providers_by_pk?: {
    readonly created_at?: string | null;
    readonly id: number;
    readonly is_active?: boolean | null;
    readonly name: string;
    readonly updated_at?: string | null;
    readonly customer_payments: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
    readonly customer_subscriptions: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  } | null;
};

export type FetchManyPlanPermissionQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<PlanPermissionsSelectColumn> | PlanPermissionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<PlanPermissionsOrderBy> | PlanPermissionsOrderBy
  >;
  where?: InputMaybe<PlanPermissionsBoolExp>;
}>;

export type FetchManyPlanPermissionQueryQuery = {
  readonly plan_permissions: ReadonlyArray<{
    readonly feature: string;
    readonly id: number;
    readonly plan: any;
  }>;
};

export type CountPlanPermissionQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<PlanPermissionsSelectColumn> | PlanPermissionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<PlanPermissionsOrderBy> | PlanPermissionsOrderBy
  >;
  where?: InputMaybe<PlanPermissionsBoolExp>;
}>;

export type CountPlanPermissionQueryQuery = {
  readonly plan_permissions_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly feature: string;
      readonly id: number;
      readonly plan: any;
    }>;
  };
};

export type FetchOnePlanPermissionQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOnePlanPermissionQueryQuery = {
  readonly plan_permissions_by_pk?: {
    readonly feature: string;
    readonly id: number;
    readonly plan: any;
  } | null;
};

export type FetchManyRecentErrorQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<RecentErrorsSelectColumn> | RecentErrorsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<RecentErrorsOrderBy> | RecentErrorsOrderBy
  >;
  where?: InputMaybe<RecentErrorsBoolExp>;
}>;

export type FetchManyRecentErrorQueryQuery = {
  readonly recent_errors: ReadonlyArray<{
    readonly created_at?: string | null;
    readonly error_type?: any | null;
    readonly message?: string | null;
    readonly metadata?: Record<string, any> | null;
    readonly service_name?: string | null;
    readonly severity?: any | null;
  }>;
};

export type CountRecentErrorQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<RecentErrorsSelectColumn> | RecentErrorsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<RecentErrorsOrderBy> | RecentErrorsOrderBy
  >;
  where?: InputMaybe<RecentErrorsBoolExp>;
}>;

export type CountRecentErrorQueryQuery = {
  readonly recent_errors_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly error_type?: any | null;
      readonly message?: string | null;
      readonly metadata?: Record<string, any> | null;
      readonly service_name?: string | null;
      readonly severity?: any | null;
    }>;
  };
};

export type FetchManyReferralStatQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ReferralStatsSelectColumn> | ReferralStatsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ReferralStatsOrderBy> | ReferralStatsOrderBy
  >;
  where?: InputMaybe<ReferralStatsBoolExp>;
}>;

export type FetchManyReferralStatQueryQuery = {
  readonly referral_stats: ReadonlyArray<{
    readonly active_days?: number | null;
    readonly avg_conversion_time_hours?: number | null;
    readonly conversion_rate?: number | null;
    readonly conversions?: number | null;
    readonly referrer_code?: string | null;
    readonly total_referrals?: number | null;
    readonly total_value?: number | null;
    readonly unique_visitors?: number | null;
  }>;
};

export type CountReferralStatQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ReferralStatsSelectColumn> | ReferralStatsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ReferralStatsOrderBy> | ReferralStatsOrderBy
  >;
  where?: InputMaybe<ReferralStatsBoolExp>;
}>;

export type CountReferralStatQueryQuery = {
  readonly referral_stats_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly active_days?: number | null;
      readonly avg_conversion_time_hours?: number | null;
      readonly conversion_rate?: number | null;
      readonly conversions?: number | null;
      readonly referrer_code?: string | null;
      readonly total_referrals?: number | null;
      readonly total_value?: number | null;
      readonly unique_visitors?: number | null;
    }>;
  };
};

export type FetchManyReferralQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ReferralsSelectColumn> | ReferralsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferralsOrderBy> | ReferralsOrderBy>;
  where?: InputMaybe<ReferralsBoolExp>;
}>;

export type FetchManyReferralQueryQuery = {
  readonly referrals: ReadonlyArray<{
    readonly browser?: string | null;
    readonly client_fingerprint?: string | null;
    readonly conversion_value?: number | null;
    readonly converted_at?: string | null;
    readonly country_code?: string | null;
    readonly created_at?: string | null;
    readonly device_type?: string | null;
    readonly id: string;
    readonly ip_address?: any | null;
    readonly is_suspicious?: boolean | null;
    readonly landing_page?: string | null;
    readonly last_failed_attempt?: string | null;
    readonly referral_status?: any | null;
    readonly referrer_code: string;
    readonly region?: string | null;
    readonly security_flags?: Record<string, any> | null;
    readonly user_agent?: string | null;
    readonly utm_campaign?: string | null;
    readonly utm_medium?: string | null;
    readonly utm_source?: string | null;
    readonly validation_attempts?: number | null;
    readonly visitor_id: string;
  }>;
};

export type CountReferralQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ReferralsSelectColumn> | ReferralsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ReferralsOrderBy> | ReferralsOrderBy>;
  where?: InputMaybe<ReferralsBoolExp>;
}>;

export type CountReferralQueryQuery = {
  readonly referrals_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly browser?: string | null;
      readonly client_fingerprint?: string | null;
      readonly conversion_value?: number | null;
      readonly converted_at?: string | null;
      readonly country_code?: string | null;
      readonly created_at?: string | null;
      readonly device_type?: string | null;
      readonly id: string;
      readonly ip_address?: any | null;
      readonly is_suspicious?: boolean | null;
      readonly landing_page?: string | null;
      readonly last_failed_attempt?: string | null;
      readonly referral_status?: any | null;
      readonly referrer_code: string;
      readonly region?: string | null;
      readonly security_flags?: Record<string, any> | null;
      readonly user_agent?: string | null;
      readonly utm_campaign?: string | null;
      readonly utm_medium?: string | null;
      readonly utm_source?: string | null;
      readonly validation_attempts?: number | null;
      readonly visitor_id: string;
    }>;
  };
};

export type FetchOneReferralQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneReferralQueryQuery = {
  readonly referrals_by_pk?: {
    readonly browser?: string | null;
    readonly client_fingerprint?: string | null;
    readonly conversion_value?: number | null;
    readonly converted_at?: string | null;
    readonly country_code?: string | null;
    readonly created_at?: string | null;
    readonly device_type?: string | null;
    readonly id: string;
    readonly ip_address?: any | null;
    readonly is_suspicious?: boolean | null;
    readonly landing_page?: string | null;
    readonly last_failed_attempt?: string | null;
    readonly referral_status?: any | null;
    readonly referrer_code: string;
    readonly region?: string | null;
    readonly security_flags?: Record<string, any> | null;
    readonly user_agent?: string | null;
    readonly utm_campaign?: string | null;
    readonly utm_medium?: string | null;
    readonly utm_source?: string | null;
    readonly validation_attempts?: number | null;
    readonly visitor_id: string;
  } | null;
};

export type FetchManyReferrerBlockQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ReferrerBlocksSelectColumn> | ReferrerBlocksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ReferrerBlocksOrderBy> | ReferrerBlocksOrderBy
  >;
  where?: InputMaybe<ReferrerBlocksBoolExp>;
}>;

export type FetchManyReferrerBlockQueryQuery = {
  readonly referrer_blocks: ReadonlyArray<{
    readonly blocked_at?: string | null;
    readonly blocked_by: string;
    readonly created_at?: string | null;
    readonly id: string;
    readonly is_permanent?: boolean | null;
    readonly reason?: string | null;
    readonly referrer_code: string;
    readonly updated_at?: string | null;
  }>;
};

export type CountReferrerBlockQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ReferrerBlocksSelectColumn> | ReferrerBlocksSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ReferrerBlocksOrderBy> | ReferrerBlocksOrderBy
  >;
  where?: InputMaybe<ReferrerBlocksBoolExp>;
}>;

export type CountReferrerBlockQueryQuery = {
  readonly referrer_blocks_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly blocked_at?: string | null;
      readonly blocked_by: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_permanent?: boolean | null;
      readonly reason?: string | null;
      readonly referrer_code: string;
      readonly updated_at?: string | null;
    }>;
  };
};

export type FetchOneReferrerBlockQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneReferrerBlockQueryQuery = {
  readonly referrer_blocks_by_pk?: {
    readonly blocked_at?: string | null;
    readonly blocked_by: string;
    readonly created_at?: string | null;
    readonly id: string;
    readonly is_permanent?: boolean | null;
    readonly reason?: string | null;
    readonly referrer_code: string;
    readonly updated_at?: string | null;
  } | null;
};

export type FetchManyReferrerRiskMetricQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<ReferrerRiskMetricsSelectColumn>
    | ReferrerRiskMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ReferrerRiskMetricsOrderBy> | ReferrerRiskMetricsOrderBy
  >;
  where?: InputMaybe<ReferrerRiskMetricsBoolExp>;
}>;

export type FetchManyReferrerRiskMetricQueryQuery = {
  readonly referrer_risk_metrics: ReadonlyArray<{
    readonly active_days?: number | null;
    readonly high_attempt_instances?: number | null;
    readonly max_validation_attempts?: number | null;
    readonly referrer_code?: string | null;
    readonly suspicious_count?: number | null;
    readonly suspicious_percentage?: number | null;
    readonly total_referrals?: number | null;
    readonly unique_ips?: number | null;
  }>;
};

export type CountReferrerRiskMetricQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<ReferrerRiskMetricsSelectColumn>
    | ReferrerRiskMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ReferrerRiskMetricsOrderBy> | ReferrerRiskMetricsOrderBy
  >;
  where?: InputMaybe<ReferrerRiskMetricsBoolExp>;
}>;

export type CountReferrerRiskMetricQueryQuery = {
  readonly referrer_risk_metrics_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly active_days?: number | null;
      readonly high_attempt_instances?: number | null;
      readonly max_validation_attempts?: number | null;
      readonly referrer_code?: string | null;
      readonly suspicious_count?: number | null;
      readonly suspicious_percentage?: number | null;
      readonly total_referrals?: number | null;
      readonly unique_ips?: number | null;
    }>;
  };
};

export type FetchManyResearchQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ResearchSelectColumn> | ResearchSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResearchOrderBy> | ResearchOrderBy>;
  where?: InputMaybe<ResearchBoolExp>;
}>;

export type FetchManyResearchQueryQuery = {
  readonly research: ReadonlyArray<{
    readonly abstract?: string | null;
    readonly abstract_url: string;
    readonly affiliations?: Record<string, any> | null;
    readonly authors?: Record<string, any> | null;
    readonly category?: string | null;
    readonly comments?: string | null;
    readonly content_status: any;
    readonly created_at: string;
    readonly doi_url?: string | null;
    readonly figure_count?: any | null;
    readonly has_embedding?: boolean | null;
    readonly id: string;
    readonly is_flagged: boolean;
    readonly keywords?: string | null;
    readonly month?: string | null;
    readonly page_count?: any | null;
    readonly pdf_url?: string | null;
    readonly published_at?: string | null;
    readonly published_in?: string | null;
    readonly summary?: string | null;
    readonly table_count?: any | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly version?: any | null;
    readonly year?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly research_embedding?: {
      readonly chunk: string;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly embedding_review_id?: number | null;
      readonly id: number;
      readonly is_flagged?: boolean | null;
      readonly research_id: string;
      readonly updated_at: string;
      readonly url?: string | null;
    } | null;
  }>;
};

export type CountResearchQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ResearchSelectColumn> | ResearchSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResearchOrderBy> | ResearchOrderBy>;
  where?: InputMaybe<ResearchBoolExp>;
}>;

export type CountResearchQueryQuery = {
  readonly research_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
    }>;
  };
};

export type FetchOneResearchQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneResearchQueryQuery = {
  readonly research_by_pk?: {
    readonly abstract?: string | null;
    readonly abstract_url: string;
    readonly affiliations?: Record<string, any> | null;
    readonly authors?: Record<string, any> | null;
    readonly category?: string | null;
    readonly comments?: string | null;
    readonly content_status: any;
    readonly created_at: string;
    readonly doi_url?: string | null;
    readonly figure_count?: any | null;
    readonly has_embedding?: boolean | null;
    readonly id: string;
    readonly is_flagged: boolean;
    readonly keywords?: string | null;
    readonly month?: string | null;
    readonly page_count?: any | null;
    readonly pdf_url?: string | null;
    readonly published_at?: string | null;
    readonly published_in?: string | null;
    readonly summary?: string | null;
    readonly table_count?: any | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly version?: any | null;
    readonly year?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly research_embedding?: {
      readonly chunk: string;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly embedding_review_id?: number | null;
      readonly id: number;
      readonly is_flagged?: boolean | null;
      readonly research_id: string;
      readonly updated_at: string;
      readonly url?: string | null;
    } | null;
  } | null;
};

export type FetchManyResearchEmbeddingQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<ResearchEmbeddingsSelectColumn>
    | ResearchEmbeddingsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ResearchEmbeddingsOrderBy> | ResearchEmbeddingsOrderBy
  >;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
}>;

export type FetchManyResearchEmbeddingQueryQuery = {
  readonly research_embeddings: ReadonlyArray<{
    readonly chunk: string;
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly embedding_review_id?: number | null;
    readonly id: number;
    readonly is_flagged?: boolean | null;
    readonly research_id: string;
    readonly updated_at: string;
    readonly url?: string | null;
    readonly embedding_review?: {
      readonly agent_review?: boolean | null;
      readonly created_at: string;
      readonly human_review?: boolean | null;
      readonly id: number;
      readonly notes?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly research: {
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
    };
  }>;
};

export type CountResearchEmbeddingQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<ResearchEmbeddingsSelectColumn>
    | ResearchEmbeddingsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ResearchEmbeddingsOrderBy> | ResearchEmbeddingsOrderBy
  >;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
}>;

export type CountResearchEmbeddingQueryQuery = {
  readonly research_embeddings_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly chunk: string;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly embedding_review_id?: number | null;
      readonly id: number;
      readonly is_flagged?: boolean | null;
      readonly research_id: string;
      readonly updated_at: string;
      readonly url?: string | null;
    }>;
  };
};

export type FetchOneResearchEmbeddingQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneResearchEmbeddingQueryQuery = {
  readonly research_embeddings_by_pk?: {
    readonly chunk: string;
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly embedding_review_id?: number | null;
    readonly id: number;
    readonly is_flagged?: boolean | null;
    readonly research_id: string;
    readonly updated_at: string;
    readonly url?: string | null;
    readonly embedding_review?: {
      readonly agent_review?: boolean | null;
      readonly created_at: string;
      readonly human_review?: boolean | null;
      readonly id: number;
      readonly notes?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly research: {
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
    };
  } | null;
};

export type FetchManyResponseQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ResponsesSelectColumn> | ResponsesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResponsesOrderBy> | ResponsesOrderBy>;
  where?: InputMaybe<ResponsesBoolExp>;
}>;

export type FetchManyResponseQueryQuery = {
  readonly responses: ReadonlyArray<{
    readonly created_at?: string | null;
    readonly downvotes?: number | null;
    readonly id: number;
    readonly output: string;
    readonly search_id: number;
    readonly upvotes?: number | null;
    readonly search: {
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: number;
      readonly input: string;
      readonly tokens_used?: any | null;
      readonly user_ids?: ReadonlyArray<string> | null;
    };
  }>;
};

export type CountResponseQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ResponsesSelectColumn> | ResponsesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<ResponsesOrderBy> | ResponsesOrderBy>;
  where?: InputMaybe<ResponsesBoolExp>;
}>;

export type CountResponseQueryQuery = {
  readonly responses_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly downvotes?: number | null;
      readonly id: number;
      readonly output: string;
      readonly search_id: number;
      readonly upvotes?: number | null;
    }>;
  };
};

export type FetchOneResponseQueryVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneResponseQueryQuery = {
  readonly responses_by_pk?: {
    readonly created_at?: string | null;
    readonly downvotes?: number | null;
    readonly id: number;
    readonly output: string;
    readonly search_id: number;
    readonly upvotes?: number | null;
    readonly search: {
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: number;
      readonly input: string;
      readonly tokens_used?: any | null;
      readonly user_ids?: ReadonlyArray<string> | null;
    };
  } | null;
};

export type FetchManyRoleHierarchyQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<RoleHierarchySelectColumn> | RoleHierarchySelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<RoleHierarchyOrderBy> | RoleHierarchyOrderBy
  >;
  where?: InputMaybe<RoleHierarchyBoolExp>;
}>;

export type FetchManyRoleHierarchyQueryQuery = {
  readonly role_hierarchy: ReadonlyArray<{
    readonly child_role: any;
    readonly parent_role: any;
  }>;
};

export type CountRoleHierarchyQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<RoleHierarchySelectColumn> | RoleHierarchySelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<RoleHierarchyOrderBy> | RoleHierarchyOrderBy
  >;
  where?: InputMaybe<RoleHierarchyBoolExp>;
}>;

export type CountRoleHierarchyQueryQuery = {
  readonly role_hierarchy_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly child_role: any;
      readonly parent_role: any;
    }>;
  };
};

export type FetchOneRoleHierarchyQueryVariables = Exact<{
  child_role: Scalars["app_role_enum"]["input"];
  parent_role: Scalars["app_role_enum"]["input"];
}>;

export type FetchOneRoleHierarchyQueryQuery = {
  readonly role_hierarchy_by_pk?: {
    readonly child_role: any;
    readonly parent_role: any;
  } | null;
};

export type FetchManyRolePermissionQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<RolePermissionsSelectColumn> | RolePermissionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<RolePermissionsOrderBy> | RolePermissionsOrderBy
  >;
  where?: InputMaybe<RolePermissionsBoolExp>;
}>;

export type FetchManyRolePermissionQueryQuery = {
  readonly role_permissions: ReadonlyArray<{
    readonly cached_permissions?: Record<string, any> | null;
    readonly conditions?: Record<string, any> | null;
    readonly id: number;
    readonly inherit_from?: ReadonlyArray<any> | null;
    readonly last_updated?: string | null;
    readonly permissions?: Record<string, any> | null;
    readonly role: any;
    readonly table_name: string;
  }>;
};

export type CountRolePermissionQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<RolePermissionsSelectColumn> | RolePermissionsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<RolePermissionsOrderBy> | RolePermissionsOrderBy
  >;
  where?: InputMaybe<RolePermissionsBoolExp>;
}>;

export type CountRolePermissionQueryQuery = {
  readonly role_permissions_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly cached_permissions?: Record<string, any> | null;
      readonly conditions?: Record<string, any> | null;
      readonly id: number;
      readonly inherit_from?: ReadonlyArray<any> | null;
      readonly last_updated?: string | null;
      readonly permissions?: Record<string, any> | null;
      readonly role: any;
      readonly table_name: string;
    }>;
  };
};

export type FetchOneRolePermissionQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneRolePermissionQueryQuery = {
  readonly role_permissions_by_pk?: {
    readonly cached_permissions?: Record<string, any> | null;
    readonly conditions?: Record<string, any> | null;
    readonly id: number;
    readonly inherit_from?: ReadonlyArray<any> | null;
    readonly last_updated?: string | null;
    readonly permissions?: Record<string, any> | null;
    readonly role: any;
    readonly table_name: string;
  } | null;
};

export type FetchManyRolePermissionsMaterializedQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<RolePermissionsMaterializedSelectColumn>
    | RolePermissionsMaterializedSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    | ReadonlyArray<RolePermissionsMaterializedOrderBy>
    | RolePermissionsMaterializedOrderBy
  >;
  where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
}>;

export type FetchManyRolePermissionsMaterializedQueryQuery = {
  readonly role_permissions_materialized: ReadonlyArray<{
    readonly last_updated?: string | null;
    readonly permissions: Record<string, any>;
    readonly role: any;
  }>;
};

export type CountRolePermissionsMaterializedQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<RolePermissionsMaterializedSelectColumn>
    | RolePermissionsMaterializedSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    | ReadonlyArray<RolePermissionsMaterializedOrderBy>
    | RolePermissionsMaterializedOrderBy
  >;
  where?: InputMaybe<RolePermissionsMaterializedBoolExp>;
}>;

export type CountRolePermissionsMaterializedQueryQuery = {
  readonly role_permissions_materialized_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly last_updated?: string | null;
      readonly permissions: Record<string, any>;
      readonly role: any;
    }>;
  };
};

export type FetchOneRolePermissionsMaterializedQueryVariables = Exact<{
  role: Scalars["app_role_enum"]["input"];
}>;

export type FetchOneRolePermissionsMaterializedQueryQuery = {
  readonly role_permissions_materialized_by_pk?: {
    readonly last_updated?: string | null;
    readonly permissions: Record<string, any>;
    readonly role: any;
  } | null;
};

export type FetchManyScoringWeightQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ScoringWeightsSelectColumn> | ScoringWeightsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ScoringWeightsOrderBy> | ScoringWeightsOrderBy
  >;
  where?: InputMaybe<ScoringWeightsBoolExp>;
}>;

export type FetchManyScoringWeightQueryQuery = {
  readonly scoring_weights: ReadonlyArray<{
    readonly description?: string | null;
    readonly id: string;
    readonly name: string;
    readonly updated_at?: string | null;
    readonly weight: any;
  }>;
};

export type CountScoringWeightQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<ScoringWeightsSelectColumn> | ScoringWeightsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ScoringWeightsOrderBy> | ScoringWeightsOrderBy
  >;
  where?: InputMaybe<ScoringWeightsBoolExp>;
}>;

export type CountScoringWeightQueryQuery = {
  readonly scoring_weights_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly description?: string | null;
      readonly id: string;
      readonly name: string;
      readonly updated_at?: string | null;
      readonly weight: any;
    }>;
  };
};

export type FetchOneScoringWeightQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneScoringWeightQueryQuery = {
  readonly scoring_weights_by_pk?: {
    readonly description?: string | null;
    readonly id: string;
    readonly name: string;
    readonly updated_at?: string | null;
    readonly weight: any;
  } | null;
};

export type FetchManySearchQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<SearchesSelectColumn> | SearchesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SearchesOrderBy> | SearchesOrderBy>;
  where?: InputMaybe<SearchesBoolExp>;
}>;

export type FetchManySearchQueryQuery = {
  readonly searches: ReadonlyArray<{
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly id: number;
    readonly input: string;
    readonly tokens_used?: any | null;
    readonly user_ids?: ReadonlyArray<string> | null;
    readonly responses: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly downvotes?: number | null;
      readonly id: number;
      readonly output: string;
      readonly search_id: number;
      readonly upvotes?: number | null;
    }>;
  }>;
};

export type CountSearchQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<SearchesSelectColumn> | SearchesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SearchesOrderBy> | SearchesOrderBy>;
  where?: InputMaybe<SearchesBoolExp>;
}>;

export type CountSearchQueryQuery = {
  readonly searches_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: number;
      readonly input: string;
      readonly tokens_used?: any | null;
      readonly user_ids?: ReadonlyArray<string> | null;
    }>;
  };
};

export type FetchOneSearchQueryVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneSearchQueryQuery = {
  readonly searches_by_pk?: {
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly id: number;
    readonly input: string;
    readonly tokens_used?: any | null;
    readonly user_ids?: ReadonlyArray<string> | null;
    readonly responses: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly downvotes?: number | null;
      readonly id: number;
      readonly output: string;
      readonly search_id: number;
      readonly upvotes?: number | null;
    }>;
  } | null;
};

export type FetchManySecurityMetricQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<SecurityMetricsSelectColumn> | SecurityMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<SecurityMetricsOrderBy> | SecurityMetricsOrderBy
  >;
  where?: InputMaybe<SecurityMetricsBoolExp>;
}>;

export type FetchManySecurityMetricQueryQuery = {
  readonly security_metrics: ReadonlyArray<{
    readonly high_attempt_count?: number | null;
    readonly max_attempts?: number | null;
    readonly suspicious_attempts?: number | null;
    readonly time_bucket?: string | null;
    readonly total_attempts?: number | null;
    readonly unique_ips?: number | null;
    readonly unique_referrers?: number | null;
  }>;
};

export type CountSecurityMetricQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<SecurityMetricsSelectColumn> | SecurityMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<SecurityMetricsOrderBy> | SecurityMetricsOrderBy
  >;
  where?: InputMaybe<SecurityMetricsBoolExp>;
}>;

export type CountSecurityMetricQueryQuery = {
  readonly security_metrics_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly high_attempt_count?: number | null;
      readonly max_attempts?: number | null;
      readonly suspicious_attempts?: number | null;
      readonly time_bucket?: string | null;
      readonly total_attempts?: number | null;
      readonly unique_ips?: number | null;
      readonly unique_referrers?: number | null;
    }>;
  };
};

export type FetchManySlowQueryPatternQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<SlowQueryPatternsSelectColumn> | SlowQueryPatternsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<SlowQueryPatternsOrderBy> | SlowQueryPatternsOrderBy
  >;
  where?: InputMaybe<SlowQueryPatternsBoolExp>;
}>;

export type FetchManySlowQueryPatternQueryQuery = {
  readonly slow_query_patterns: ReadonlyArray<{
    readonly avg_exec_time?: any | null;
    readonly first_seen?: string | null;
    readonly last_seen?: string | null;
    readonly max_exec_time?: any | null;
    readonly occurrence_count?: number | null;
    readonly query_id?: string | null;
  }>;
};

export type CountSlowQueryPatternQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<SlowQueryPatternsSelectColumn> | SlowQueryPatternsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<SlowQueryPatternsOrderBy> | SlowQueryPatternsOrderBy
  >;
  where?: InputMaybe<SlowQueryPatternsBoolExp>;
}>;

export type CountSlowQueryPatternQueryQuery = {
  readonly slow_query_patterns_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly avg_exec_time?: any | null;
      readonly first_seen?: string | null;
      readonly last_seen?: string | null;
      readonly max_exec_time?: any | null;
      readonly occurrence_count?: number | null;
      readonly query_id?: string | null;
    }>;
  };
};

export type FetchManySocialMediaQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<SocialMediaSelectColumn> | SocialMediaSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SocialMediaOrderBy> | SocialMediaOrderBy>;
  where?: InputMaybe<SocialMediaBoolExp>;
}>;

export type FetchManySocialMediaQueryQuery = {
  readonly social_media: ReadonlyArray<{
    readonly created_at?: string | null;
    readonly facebook_url?: string | null;
    readonly id: number;
    readonly instagram_url?: string | null;
    readonly linkedin_url?: string | null;
    readonly twitter_url?: string | null;
    readonly updated_at?: string | null;
    readonly youtube_url?: string | null;
    readonly companies: ReadonlyArray<{
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
  }>;
};

export type CountSocialMediaQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<SocialMediaSelectColumn> | SocialMediaSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<SocialMediaOrderBy> | SocialMediaOrderBy>;
  where?: InputMaybe<SocialMediaBoolExp>;
}>;

export type CountSocialMediaQueryQuery = {
  readonly social_media_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly facebook_url?: string | null;
      readonly id: number;
      readonly instagram_url?: string | null;
      readonly linkedin_url?: string | null;
      readonly twitter_url?: string | null;
      readonly updated_at?: string | null;
      readonly youtube_url?: string | null;
    }>;
  };
};

export type FetchOneSocialMediaQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneSocialMediaQueryQuery = {
  readonly social_media_by_pk?: {
    readonly created_at?: string | null;
    readonly facebook_url?: string | null;
    readonly id: number;
    readonly instagram_url?: string | null;
    readonly linkedin_url?: string | null;
    readonly twitter_url?: string | null;
    readonly updated_at?: string | null;
    readonly youtube_url?: string | null;
    readonly companies: ReadonlyArray<{
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
  } | null;
};

export type FetchManySpiderMetricQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<SpiderMetricsSelectColumn> | SpiderMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<SpiderMetricsOrderBy> | SpiderMetricsOrderBy
  >;
  where?: InputMaybe<SpiderMetricsBoolExp>;
}>;

export type FetchManySpiderMetricQueryQuery = {
  readonly spider_metrics: ReadonlyArray<{
    readonly crawl_id: string;
    readonly id: number;
    readonly metric_id?: number | null;
    readonly timestamp: string;
    readonly value: Record<string, any>;
    readonly metric_definition?: {
      readonly category?: string | null;
      readonly description?: string | null;
      readonly id: number;
      readonly is_dimensional?: boolean | null;
      readonly name: string;
      readonly type: string;
      readonly unit?: string | null;
    } | null;
  }>;
};

export type CountSpiderMetricQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<SpiderMetricsSelectColumn> | SpiderMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<SpiderMetricsOrderBy> | SpiderMetricsOrderBy
  >;
  where?: InputMaybe<SpiderMetricsBoolExp>;
}>;

export type CountSpiderMetricQueryQuery = {
  readonly spider_metrics_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
    }>;
  };
};

export type FetchOneSpiderMetricQueryVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type FetchOneSpiderMetricQueryQuery = {
  readonly spider_metrics_by_pk?: {
    readonly crawl_id: string;
    readonly id: number;
    readonly metric_id?: number | null;
    readonly timestamp: string;
    readonly value: Record<string, any>;
    readonly metric_definition?: {
      readonly category?: string | null;
      readonly description?: string | null;
      readonly id: number;
      readonly is_dimensional?: boolean | null;
      readonly name: string;
      readonly type: string;
      readonly unit?: string | null;
    } | null;
  } | null;
};

export type FetchManyStrapiMigrationQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<StrapiMigrationsSelectColumn> | StrapiMigrationsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<StrapiMigrationsOrderBy> | StrapiMigrationsOrderBy
  >;
  where?: InputMaybe<StrapiMigrationsBoolExp>;
}>;

export type FetchManyStrapiMigrationQueryQuery = {
  readonly strapi_migrations: ReadonlyArray<{
    readonly id: number;
    readonly name?: string | null;
    readonly time?: string | null;
  }>;
};

export type CountStrapiMigrationQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<StrapiMigrationsSelectColumn> | StrapiMigrationsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<StrapiMigrationsOrderBy> | StrapiMigrationsOrderBy
  >;
  where?: InputMaybe<StrapiMigrationsBoolExp>;
}>;

export type CountStrapiMigrationQueryQuery = {
  readonly strapi_migrations_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly id: number;
      readonly name?: string | null;
      readonly time?: string | null;
    }>;
  };
};

export type FetchOneStrapiMigrationQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneStrapiMigrationQueryQuery = {
  readonly strapi_migrations_by_pk?: {
    readonly id: number;
    readonly name?: string | null;
    readonly time?: string | null;
  } | null;
};

export type FetchManyStrapiMigrationsInternalQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<StrapiMigrationsInternalSelectColumn>
    | StrapiMigrationsInternalSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    | ReadonlyArray<StrapiMigrationsInternalOrderBy>
    | StrapiMigrationsInternalOrderBy
  >;
  where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
}>;

export type FetchManyStrapiMigrationsInternalQueryQuery = {
  readonly strapi_migrations_internal: ReadonlyArray<{
    readonly id: number;
    readonly name?: string | null;
    readonly time?: string | null;
  }>;
};

export type CountStrapiMigrationsInternalQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<StrapiMigrationsInternalSelectColumn>
    | StrapiMigrationsInternalSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    | ReadonlyArray<StrapiMigrationsInternalOrderBy>
    | StrapiMigrationsInternalOrderBy
  >;
  where?: InputMaybe<StrapiMigrationsInternalBoolExp>;
}>;

export type CountStrapiMigrationsInternalQueryQuery = {
  readonly strapi_migrations_internal_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly id: number;
      readonly name?: string | null;
      readonly time?: string | null;
    }>;
  };
};

export type FetchOneStrapiMigrationsInternalQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneStrapiMigrationsInternalQueryQuery = {
  readonly strapi_migrations_internal_by_pk?: {
    readonly id: number;
    readonly name?: string | null;
    readonly time?: string | null;
  } | null;
};

export type FetchManyTableMaintenanceLogQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<TableMaintenanceLogSelectColumn>
    | TableMaintenanceLogSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<TableMaintenanceLogOrderBy> | TableMaintenanceLogOrderBy
  >;
  where?: InputMaybe<TableMaintenanceLogBoolExp>;
}>;

export type FetchManyTableMaintenanceLogQueryQuery = {
  readonly table_maintenance_log: ReadonlyArray<{
    readonly detail?: string | null;
    readonly id: number;
    readonly logged_at?: string | null;
    readonly operation?: string | null;
  }>;
};

export type CountTableMaintenanceLogQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<TableMaintenanceLogSelectColumn>
    | TableMaintenanceLogSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<TableMaintenanceLogOrderBy> | TableMaintenanceLogOrderBy
  >;
  where?: InputMaybe<TableMaintenanceLogBoolExp>;
}>;

export type CountTableMaintenanceLogQueryQuery = {
  readonly table_maintenance_log_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly detail?: string | null;
      readonly id: number;
      readonly logged_at?: string | null;
      readonly operation?: string | null;
    }>;
  };
};

export type FetchOneTableMaintenanceLogQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneTableMaintenanceLogQueryQuery = {
  readonly table_maintenance_log_by_pk?: {
    readonly detail?: string | null;
    readonly id: number;
    readonly logged_at?: string | null;
    readonly operation?: string | null;
  } | null;
};

export type FetchManyTableQueryPerformanceQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<TableQueryPerformanceSelectColumn>
    | TableQueryPerformanceSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<TableQueryPerformanceOrderBy> | TableQueryPerformanceOrderBy
  >;
  where?: InputMaybe<TableQueryPerformanceBoolExp>;
}>;

export type FetchManyTableQueryPerformanceQueryQuery = {
  readonly table_query_performance: ReadonlyArray<{
    readonly avg_duration?: any | null;
    readonly capture_time?: string | null;
    readonly execution_count?: number | null;
    readonly query?: string | null;
  }>;
};

export type CountTableQueryPerformanceQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<TableQueryPerformanceSelectColumn>
    | TableQueryPerformanceSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<TableQueryPerformanceOrderBy> | TableQueryPerformanceOrderBy
  >;
  where?: InputMaybe<TableQueryPerformanceBoolExp>;
}>;

export type CountTableQueryPerformanceQueryQuery = {
  readonly table_query_performance_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly avg_duration?: any | null;
      readonly capture_time?: string | null;
      readonly execution_count?: number | null;
      readonly query?: string | null;
    }>;
  };
};

export type FetchManyTableSequenceUsageQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<TableSequenceUsageSelectColumn>
    | TableSequenceUsageSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<TableSequenceUsageOrderBy> | TableSequenceUsageOrderBy
  >;
  where?: InputMaybe<TableSequenceUsageBoolExp>;
}>;

export type FetchManyTableSequenceUsageQueryQuery = {
  readonly table_sequence_usage: ReadonlyArray<{
    readonly capture_time?: string | null;
    readonly current_value?: number | null;
    readonly max_value?: number | null;
    readonly sequence_name?: string | null;
  }>;
};

export type CountTableSequenceUsageQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    | ReadonlyArray<TableSequenceUsageSelectColumn>
    | TableSequenceUsageSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<TableSequenceUsageOrderBy> | TableSequenceUsageOrderBy
  >;
  where?: InputMaybe<TableSequenceUsageBoolExp>;
}>;

export type CountTableSequenceUsageQueryQuery = {
  readonly table_sequence_usage_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly capture_time?: string | null;
      readonly current_value?: number | null;
      readonly max_value?: number | null;
      readonly sequence_name?: string | null;
    }>;
  };
};

export type FetchManyTableStatisticQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<TableStatisticsSelectColumn> | TableStatisticsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<TableStatisticsOrderBy> | TableStatisticsOrderBy
  >;
  where?: InputMaybe<TableStatisticsBoolExp>;
}>;

export type FetchManyTableStatisticQueryQuery = {
  readonly table_statistics: ReadonlyArray<{
    readonly buffer_cache_hit_ratio?: any | null;
    readonly capture_time: string;
    readonly dead_tuples?: number | null;
    readonly estimated_bloat_ratio?: any | null;
    readonly index_scan_count?: number | null;
    readonly index_size?: number | null;
    readonly index_usage?: Record<string, any> | null;
    readonly last_analyze?: string | null;
    readonly last_vacuum?: string | null;
    readonly live_tuples?: number | null;
    readonly row_count?: number | null;
    readonly seq_scan_count?: number | null;
    readonly table_name: string;
    readonly table_size?: number | null;
  }>;
};

export type CountTableStatisticQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<TableStatisticsSelectColumn> | TableStatisticsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<TableStatisticsOrderBy> | TableStatisticsOrderBy
  >;
  where?: InputMaybe<TableStatisticsBoolExp>;
}>;

export type CountTableStatisticQueryQuery = {
  readonly table_statistics_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly buffer_cache_hit_ratio?: any | null;
      readonly capture_time: string;
      readonly dead_tuples?: number | null;
      readonly estimated_bloat_ratio?: any | null;
      readonly index_scan_count?: number | null;
      readonly index_size?: number | null;
      readonly index_usage?: Record<string, any> | null;
      readonly last_analyze?: string | null;
      readonly last_vacuum?: string | null;
      readonly live_tuples?: number | null;
      readonly row_count?: number | null;
      readonly seq_scan_count?: number | null;
      readonly table_name: string;
      readonly table_size?: number | null;
    }>;
  };
};

export type FetchOneTableStatisticQueryVariables = Exact<{
  capture_time: Scalars["timestamptz"]["input"];
  table_name: Scalars["String"]["input"];
}>;

export type FetchOneTableStatisticQueryQuery = {
  readonly table_statistics_by_pk?: {
    readonly buffer_cache_hit_ratio?: any | null;
    readonly capture_time: string;
    readonly dead_tuples?: number | null;
    readonly estimated_bloat_ratio?: any | null;
    readonly index_scan_count?: number | null;
    readonly index_size?: number | null;
    readonly index_usage?: Record<string, any> | null;
    readonly last_analyze?: string | null;
    readonly last_vacuum?: string | null;
    readonly live_tuples?: number | null;
    readonly row_count?: number | null;
    readonly seq_scan_count?: number | null;
    readonly table_name: string;
    readonly table_size?: number | null;
  } | null;
};

export type FetchManyTagQueryVariables = Exact<{
  distinct_on?: InputMaybe<ReadonlyArray<TagsSelectColumn> | TagsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TagsOrderBy> | TagsOrderBy>;
  where?: InputMaybe<TagsBoolExp>;
}>;

export type FetchManyTagQueryQuery = {
  readonly tags: ReadonlyArray<{
    readonly body?: string | null;
    readonly created_at?: string | null;
    readonly document_id?: string | null;
    readonly id: number;
    readonly locale?: string | null;
    readonly name: string;
    readonly published_at?: string | null;
    readonly updated_at?: string | null;
    readonly content_tags: ReadonlyArray<{
      readonly content_id: string;
      readonly tag_id: number;
    }>;
    readonly news_tags: ReadonlyArray<{
      readonly id: number;
      readonly news_id?: string | null;
      readonly tag_id: number;
    }>;
  }>;
};

export type CountTagQueryVariables = Exact<{
  distinct_on?: InputMaybe<ReadonlyArray<TagsSelectColumn> | TagsSelectColumn>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<TagsOrderBy> | TagsOrderBy>;
  where?: InputMaybe<TagsBoolExp>;
}>;

export type CountTagQueryQuery = {
  readonly tags_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly body?: string | null;
      readonly created_at?: string | null;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    }>;
  };
};

export type FetchOneTagQueryVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type FetchOneTagQueryQuery = {
  readonly tags_by_pk?: {
    readonly body?: string | null;
    readonly created_at?: string | null;
    readonly document_id?: string | null;
    readonly id: number;
    readonly locale?: string | null;
    readonly name: string;
    readonly published_at?: string | null;
    readonly updated_at?: string | null;
    readonly content_tags: ReadonlyArray<{
      readonly content_id: string;
      readonly tag_id: number;
    }>;
    readonly news_tags: ReadonlyArray<{
      readonly id: number;
      readonly news_id?: string | null;
      readonly tag_id: number;
    }>;
  } | null;
};

export type FetchManyUserMetricQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<UserMetricsSelectColumn> | UserMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<UserMetricsOrderBy> | UserMetricsOrderBy>;
  where?: InputMaybe<UserMetricsBoolExp>;
}>;

export type FetchManyUserMetricQueryQuery = {
  readonly user_metrics: ReadonlyArray<{
    readonly achievements?: Record<string, any> | null;
    readonly best_streak?: number | null;
    readonly created_at?: string | null;
    readonly current_level?: number | null;
    readonly current_streak?: number | null;
    readonly current_xp?: number | null;
    readonly downvote_count?: number | null;
    readonly id: string;
    readonly interaction_stats?: Record<string, any> | null;
    readonly last_vote_date?: string | null;
    readonly multipliers?: Record<string, any> | null;
    readonly points?: number | null;
    readonly points_breakdown?: Record<string, any> | null;
    readonly titles?: Record<string, any> | null;
    readonly today_vote_count?: number | null;
    readonly total_reading_time?: number | null;
    readonly total_votes?: number | null;
    readonly updated_at?: string | null;
    readonly upvote_count?: number | null;
    readonly user_id: string;
    readonly vote_accuracy?: number | null;
    readonly xp_to_next_level?: number | null;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  }>;
};

export type CountUserMetricQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<UserMetricsSelectColumn> | UserMetricsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<UserMetricsOrderBy> | UserMetricsOrderBy>;
  where?: InputMaybe<UserMetricsBoolExp>;
}>;

export type CountUserMetricQueryQuery = {
  readonly user_metrics_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly achievements?: Record<string, any> | null;
      readonly best_streak?: number | null;
      readonly created_at?: string | null;
      readonly current_level?: number | null;
      readonly current_streak?: number | null;
      readonly current_xp?: number | null;
      readonly downvote_count?: number | null;
      readonly id: string;
      readonly interaction_stats?: Record<string, any> | null;
      readonly last_vote_date?: string | null;
      readonly multipliers?: Record<string, any> | null;
      readonly points?: number | null;
      readonly points_breakdown?: Record<string, any> | null;
      readonly titles?: Record<string, any> | null;
      readonly today_vote_count?: number | null;
      readonly total_reading_time?: number | null;
      readonly total_votes?: number | null;
      readonly updated_at?: string | null;
      readonly upvote_count?: number | null;
      readonly user_id: string;
      readonly vote_accuracy?: number | null;
      readonly xp_to_next_level?: number | null;
    }>;
  };
};

export type FetchOneUserMetricQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneUserMetricQueryQuery = {
  readonly user_metrics_by_pk?: {
    readonly achievements?: Record<string, any> | null;
    readonly best_streak?: number | null;
    readonly created_at?: string | null;
    readonly current_level?: number | null;
    readonly current_streak?: number | null;
    readonly current_xp?: number | null;
    readonly downvote_count?: number | null;
    readonly id: string;
    readonly interaction_stats?: Record<string, any> | null;
    readonly last_vote_date?: string | null;
    readonly multipliers?: Record<string, any> | null;
    readonly points?: number | null;
    readonly points_breakdown?: Record<string, any> | null;
    readonly titles?: Record<string, any> | null;
    readonly today_vote_count?: number | null;
    readonly total_reading_time?: number | null;
    readonly total_votes?: number | null;
    readonly updated_at?: string | null;
    readonly upvote_count?: number | null;
    readonly user_id: string;
    readonly vote_accuracy?: number | null;
    readonly xp_to_next_level?: number | null;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type FetchManyUserProfileQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<UserProfilesSelectColumn> | UserProfilesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<UserProfilesOrderBy> | UserProfilesOrderBy
  >;
  where?: InputMaybe<UserProfilesBoolExp>;
}>;

export type FetchManyUserProfileQueryQuery = {
  readonly user_profiles: ReadonlyArray<{
    readonly avatar?: string | null;
    readonly created_at?: string | null;
    readonly dob?: any | null;
    readonly email: string;
    readonly followed_count?: number | null;
    readonly followers_count?: number | null;
    readonly gender_id?: any | null;
    readonly given_name?: string | null;
    readonly id: string;
    readonly introduction?: string | null;
    readonly is_active?: boolean | null;
    readonly last_seen?: string | null;
    readonly plan?: any | null;
    readonly role: any;
    readonly surname?: string | null;
    readonly updated_at?: string | null;
    readonly username?: string | null;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly comments: ReadonlyArray<{
      readonly content: string;
      readonly content_id: string;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly parent_comment_id?: string | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly company_employees: ReadonlyArray<{
      readonly access_level: any;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date?: string | null;
      readonly id: string;
      readonly job_description?: string | null;
      readonly role: string;
      readonly start_date?: string | null;
      readonly status?: boolean | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly content_source_visits: ReadonlyArray<{
      readonly content_id: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id?: string | null;
    }>;
    readonly customer_payments: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
    readonly customer_subscriptions: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly feedbacks: ReadonlyArray<{
      readonly created_at: string;
      readonly device_info?: string | null;
      readonly feedback_status?: any | null;
      readonly feedback_type?: any | null;
      readonly id: number;
      readonly message: string;
      readonly page_identifier: string;
      readonly rating?: number | null;
      readonly resolution_comment?: string | null;
      readonly updated_at: string;
      readonly user_id?: string | null;
    }>;
    readonly feeds: ReadonlyArray<{
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly follows: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly followed_entity: any;
      readonly followed_id: string;
      readonly id: string;
      readonly user_id: string;
    }>;
    readonly user_metric?: {
      readonly achievements?: Record<string, any> | null;
      readonly best_streak?: number | null;
      readonly created_at?: string | null;
      readonly current_level?: number | null;
      readonly current_streak?: number | null;
      readonly current_xp?: number | null;
      readonly downvote_count?: number | null;
      readonly id: string;
      readonly interaction_stats?: Record<string, any> | null;
      readonly last_vote_date?: string | null;
      readonly multipliers?: Record<string, any> | null;
      readonly points?: number | null;
      readonly points_breakdown?: Record<string, any> | null;
      readonly titles?: Record<string, any> | null;
      readonly today_vote_count?: number | null;
      readonly total_reading_time?: number | null;
      readonly total_votes?: number | null;
      readonly updated_at?: string | null;
      readonly upvote_count?: number | null;
      readonly user_id: string;
      readonly vote_accuracy?: number | null;
      readonly xp_to_next_level?: number | null;
    } | null;
  }>;
};

export type CountUserProfileQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<UserProfilesSelectColumn> | UserProfilesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<UserProfilesOrderBy> | UserProfilesOrderBy
  >;
  where?: InputMaybe<UserProfilesBoolExp>;
}>;

export type CountUserProfileQueryQuery = {
  readonly user_profiles_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    }>;
  };
};

export type FetchOneUserProfileQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneUserProfileQueryQuery = {
  readonly user_profiles_by_pk?: {
    readonly avatar?: string | null;
    readonly created_at?: string | null;
    readonly dob?: any | null;
    readonly email: string;
    readonly followed_count?: number | null;
    readonly followers_count?: number | null;
    readonly gender_id?: any | null;
    readonly given_name?: string | null;
    readonly id: string;
    readonly introduction?: string | null;
    readonly is_active?: boolean | null;
    readonly last_seen?: string | null;
    readonly plan?: any | null;
    readonly role: any;
    readonly surname?: string | null;
    readonly updated_at?: string | null;
    readonly username?: string | null;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly comments: ReadonlyArray<{
      readonly content: string;
      readonly content_id: string;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly parent_comment_id?: string | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly company_employees: ReadonlyArray<{
      readonly access_level: any;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date?: string | null;
      readonly id: string;
      readonly job_description?: string | null;
      readonly role: string;
      readonly start_date?: string | null;
      readonly status?: boolean | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly content_source_visits: ReadonlyArray<{
      readonly content_id: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id?: string | null;
    }>;
    readonly customer_payments: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
    readonly customer_subscriptions: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly feedbacks: ReadonlyArray<{
      readonly created_at: string;
      readonly device_info?: string | null;
      readonly feedback_status?: any | null;
      readonly feedback_type?: any | null;
      readonly id: number;
      readonly message: string;
      readonly page_identifier: string;
      readonly rating?: number | null;
      readonly resolution_comment?: string | null;
      readonly updated_at: string;
      readonly user_id?: string | null;
    }>;
    readonly feeds: ReadonlyArray<{
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly follows: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly followed_entity: any;
      readonly followed_id: string;
      readonly id: string;
      readonly user_id: string;
    }>;
    readonly user_metric?: {
      readonly achievements?: Record<string, any> | null;
      readonly best_streak?: number | null;
      readonly created_at?: string | null;
      readonly current_level?: number | null;
      readonly current_streak?: number | null;
      readonly current_xp?: number | null;
      readonly downvote_count?: number | null;
      readonly id: string;
      readonly interaction_stats?: Record<string, any> | null;
      readonly last_vote_date?: string | null;
      readonly multipliers?: Record<string, any> | null;
      readonly points?: number | null;
      readonly points_breakdown?: Record<string, any> | null;
      readonly titles?: Record<string, any> | null;
      readonly today_vote_count?: number | null;
      readonly total_reading_time?: number | null;
      readonly total_votes?: number | null;
      readonly updated_at?: string | null;
      readonly upvote_count?: number | null;
      readonly user_id: string;
      readonly vote_accuracy?: number | null;
      readonly xp_to_next_level?: number | null;
    } | null;
  } | null;
};

export type FetchManyVoteQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<VotesSelectColumn> | VotesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<VotesOrderBy> | VotesOrderBy>;
  where?: InputMaybe<VotesBoolExp>;
}>;

export type FetchManyVoteQueryQuery = {
  readonly votes: ReadonlyArray<{
    readonly content_id: string;
    readonly content_type: string;
    readonly created_at?: string | null;
    readonly id: string;
    readonly user_id: string;
    readonly vote_type: any;
  }>;
};

export type CountVoteQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<VotesSelectColumn> | VotesSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<VotesOrderBy> | VotesOrderBy>;
  where?: InputMaybe<VotesBoolExp>;
}>;

export type CountVoteQueryQuery = {
  readonly votes_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id: string;
      readonly vote_type: any;
    }>;
  };
};

export type FetchOneVoteQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneVoteQueryQuery = {
  readonly votes_by_pk?: {
    readonly content_id: string;
    readonly content_type: string;
    readonly created_at?: string | null;
    readonly id: string;
    readonly user_id: string;
    readonly vote_type: any;
  } | null;
};

export type FetchManyWorkflowQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<WorkflowsSelectColumn> | WorkflowsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<WorkflowsOrderBy> | WorkflowsOrderBy>;
  where?: InputMaybe<WorkflowsBoolExp>;
}>;

export type FetchManyWorkflowQueryQuery = {
  readonly workflows: ReadonlyArray<{
    readonly completed_at?: string | null;
    readonly created_at?: string | null;
    readonly id: string;
    readonly metadata?: Record<string, any> | null;
    readonly name: string;
    readonly started_at?: string | null;
    readonly status: any;
    readonly updated_at?: string | null;
  }>;
};

export type CountWorkflowQueryVariables = Exact<{
  distinct_on?: InputMaybe<
    ReadonlyArray<WorkflowsSelectColumn> | WorkflowsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<ReadonlyArray<WorkflowsOrderBy> | WorkflowsOrderBy>;
  where?: InputMaybe<WorkflowsBoolExp>;
}>;

export type CountWorkflowQueryQuery = {
  readonly workflows_aggregate: {
    readonly nodes: ReadonlyArray<{
      readonly completed_at?: string | null;
      readonly created_at?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly name: string;
      readonly started_at?: string | null;
      readonly status: any;
      readonly updated_at?: string | null;
    }>;
  };
};

export type FetchOneWorkflowQueryVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type FetchOneWorkflowQueryQuery = {
  readonly workflows_by_pk?: {
    readonly completed_at?: string | null;
    readonly created_at?: string | null;
    readonly id: string;
    readonly metadata?: Record<string, any> | null;
    readonly name: string;
    readonly started_at?: string | null;
    readonly status: any;
    readonly updated_at?: string | null;
  } | null;
};

export type DeleteManyAdDailyMetricMutationVariables = Exact<{
  where: AdDailyMetricsBoolExp;
}>;

export type DeleteManyAdDailyMetricMutationQuery = {
  readonly delete_ad_daily_metrics?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly clicks?: number | null;
      readonly created_at?: string | null;
      readonly date: any;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly variant_id?: string | null;
      readonly views?: number | null;
      readonly ad_variant?: {
        readonly active?: boolean | null;
        readonly ad_id: string;
        readonly content: Record<string, any>;
        readonly created_at?: string | null;
        readonly id: string;
        readonly is_control?: boolean | null;
        readonly performance_metrics?: Record<string, any> | null;
        readonly updated_at?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneAdDailyMetricMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneAdDailyMetricMutationQuery = {
  readonly delete_ad_daily_metrics_by_pk?: {
    readonly clicks?: number | null;
    readonly created_at?: string | null;
    readonly date: any;
    readonly id: string;
    readonly updated_at?: string | null;
    readonly variant_id?: string | null;
    readonly views?: number | null;
    readonly ad_variant?: {
      readonly active?: boolean | null;
      readonly ad_id: string;
      readonly content: Record<string, any>;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_control?: boolean | null;
      readonly performance_metrics?: Record<string, any> | null;
      readonly updated_at?: string | null;
    } | null;
  } | null;
};

export type DeleteManyAdPackageMutationVariables = Exact<{
  where: AdPackagesBoolExp;
}>;

export type DeleteManyAdPackageMutationQuery = {
  readonly delete_ad_packages?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly avg_roi?: number | null;
      readonly created_at?: string | null;
      readonly description: string;
      readonly expected_ctr?: number | null;
      readonly features: ReadonlyArray<string>;
      readonly id: string;
      readonly name: string;
      readonly position: string;
      readonly price: number;
      readonly updated_at?: string | null;
      readonly view_frequency?: number | null;
      readonly ads: ReadonlyArray<{
        readonly active?: boolean | null;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly id: string;
        readonly package_id?: string | null;
        readonly start_date: string;
        readonly updated_at?: string | null;
      }>;
    }>;
  } | null;
};

export type DeleteOneAdPackageMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneAdPackageMutationQuery = {
  readonly delete_ad_packages_by_pk?: {
    readonly active?: boolean | null;
    readonly avg_roi?: number | null;
    readonly created_at?: string | null;
    readonly description: string;
    readonly expected_ctr?: number | null;
    readonly features: ReadonlyArray<string>;
    readonly id: string;
    readonly name: string;
    readonly position: string;
    readonly price: number;
    readonly updated_at?: string | null;
    readonly view_frequency?: number | null;
    readonly ads: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type DeleteManyAdVariantMutationVariables = Exact<{
  where: AdVariantsBoolExp;
}>;

export type DeleteManyAdVariantMutationQuery = {
  readonly delete_ad_variants?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly ad_id: string;
      readonly content: Record<string, any>;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_control?: boolean | null;
      readonly performance_metrics?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly ad: {
        readonly active?: boolean | null;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly id: string;
        readonly package_id?: string | null;
        readonly start_date: string;
        readonly updated_at?: string | null;
      };
      readonly ad_daily_metrics: ReadonlyArray<{
        readonly clicks?: number | null;
        readonly created_at?: string | null;
        readonly date: any;
        readonly id: string;
        readonly updated_at?: string | null;
        readonly variant_id?: string | null;
        readonly views?: number | null;
      }>;
    }>;
  } | null;
};

export type DeleteOneAdVariantMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneAdVariantMutationQuery = {
  readonly delete_ad_variants_by_pk?: {
    readonly active?: boolean | null;
    readonly ad_id: string;
    readonly content: Record<string, any>;
    readonly created_at?: string | null;
    readonly id: string;
    readonly is_control?: boolean | null;
    readonly performance_metrics?: Record<string, any> | null;
    readonly updated_at?: string | null;
    readonly ad: {
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    };
    readonly ad_daily_metrics: ReadonlyArray<{
      readonly clicks?: number | null;
      readonly created_at?: string | null;
      readonly date: any;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly variant_id?: string | null;
      readonly views?: number | null;
    }>;
  } | null;
};

export type DeleteManyAddressMutationVariables = Exact<{
  where: AddressesBoolExp;
}>;

export type DeleteManyAddressMutationQuery = {
  readonly delete_addresses?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
      readonly city: {
        readonly country_id: number;
        readonly id: number;
        readonly name: string;
        readonly state?: string | null;
      };
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly country: {
        readonly code: string;
        readonly code_3?: string | null;
        readonly id: number;
        readonly name: string;
      };
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneAddressMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneAddressMutationQuery = {
  readonly delete_addresses_by_pk?: {
    readonly address_type?: any | null;
    readonly city_id: number;
    readonly company_id?: string | null;
    readonly country_id: number;
    readonly created_at?: string | null;
    readonly id: number;
    readonly is_primary?: boolean | null;
    readonly name?: string | null;
    readonly street1: string;
    readonly street2?: string | null;
    readonly updated_at?: string | null;
    readonly user_id?: string | null;
    readonly city: {
      readonly country_id: number;
      readonly id: number;
      readonly name: string;
      readonly state?: string | null;
    };
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly country: {
      readonly code: string;
      readonly code_3?: string | null;
      readonly id: number;
      readonly name: string;
    };
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type DeleteManyAdMutationVariables = Exact<{
  where: AdsBoolExp;
}>;

export type DeleteManyAdMutationQuery = {
  readonly delete_ads?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
      readonly ad_package?: {
        readonly active?: boolean | null;
        readonly avg_roi?: number | null;
        readonly created_at?: string | null;
        readonly description: string;
        readonly expected_ctr?: number | null;
        readonly features: ReadonlyArray<string>;
        readonly id: string;
        readonly name: string;
        readonly position: string;
        readonly price: number;
        readonly updated_at?: string | null;
        readonly view_frequency?: number | null;
      } | null;
      readonly ad_variants: ReadonlyArray<{
        readonly active?: boolean | null;
        readonly ad_id: string;
        readonly content: Record<string, any>;
        readonly created_at?: string | null;
        readonly id: string;
        readonly is_control?: boolean | null;
        readonly performance_metrics?: Record<string, any> | null;
        readonly updated_at?: string | null;
      }>;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null;
};

export type DeleteOneAdMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneAdMutationQuery = {
  readonly delete_ads_by_pk?: {
    readonly active?: boolean | null;
    readonly company_id?: string | null;
    readonly created_at?: string | null;
    readonly end_date: string;
    readonly id: string;
    readonly package_id?: string | null;
    readonly start_date: string;
    readonly updated_at?: string | null;
    readonly ad_package?: {
      readonly active?: boolean | null;
      readonly avg_roi?: number | null;
      readonly created_at?: string | null;
      readonly description: string;
      readonly expected_ctr?: number | null;
      readonly features: ReadonlyArray<string>;
      readonly id: string;
      readonly name: string;
      readonly position: string;
      readonly price: number;
      readonly updated_at?: string | null;
      readonly view_frequency?: number | null;
    } | null;
    readonly ad_variants: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly ad_id: string;
      readonly content: Record<string, any>;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_control?: boolean | null;
      readonly performance_metrics?: Record<string, any> | null;
      readonly updated_at?: string | null;
    }>;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type DeleteManyBlacklistedDomainMutationVariables = Exact<{
  where: BlacklistedDomainsBoolExp;
}>;

export type DeleteManyBlacklistedDomainMutationQuery = {
  readonly delete_blacklisted_domains?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at: string;
      readonly id: string;
      readonly reason?: string | null;
      readonly url: string;
    }>;
  } | null;
};

export type DeleteOneBlacklistedDomainMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneBlacklistedDomainMutationQuery = {
  readonly delete_blacklisted_domains_by_pk?: {
    readonly created_at: string;
    readonly id: string;
    readonly reason?: string | null;
    readonly url: string;
  } | null;
};

export type DeleteManyBlacklistedUrlMutationVariables = Exact<{
  where: BlacklistedUrlsBoolExp;
}>;

export type DeleteManyBlacklistedUrlMutationQuery = {
  readonly delete_blacklisted_urls?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly id: number;
      readonly reason?: string | null;
      readonly url: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null;
};

export type DeleteOneBlacklistedUrlMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneBlacklistedUrlMutationQuery = {
  readonly delete_blacklisted_urls_by_pk?: {
    readonly company_id?: string | null;
    readonly created_at?: string | null;
    readonly id: number;
    readonly reason?: string | null;
    readonly url: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type DeleteManyBlockedIpMutationVariables = Exact<{
  where: BlockedIpsBoolExp;
}>;

export type DeleteManyBlockedIpMutationQuery = {
  readonly delete_blocked_ips?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly blocked_at?: string | null;
      readonly blocked_until: string;
      readonly created_at?: string | null;
      readonly failed_attempts?: number | null;
      readonly id: string;
      readonly ip_address: any;
      readonly reason?: string | null;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type DeleteOneBlockedIpMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneBlockedIpMutationQuery = {
  readonly delete_blocked_ips_by_pk?: {
    readonly blocked_at?: string | null;
    readonly blocked_until: string;
    readonly created_at?: string | null;
    readonly failed_attempts?: number | null;
    readonly id: string;
    readonly ip_address: any;
    readonly reason?: string | null;
    readonly updated_at?: string | null;
  } | null;
};

export type DeleteManyBookmarkFolderMutationVariables = Exact<{
  where: BookmarkFoldersBoolExp;
}>;

export type DeleteManyBookmarkFolderMutationQuery = {
  readonly delete_bookmark_folders?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly color?: string | null;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_default?: boolean | null;
      readonly is_favorite?: boolean | null;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly path?: any | null;
      readonly position?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly bookmarks: ReadonlyArray<{
        readonly content_id: string;
        readonly content_type: string;
        readonly created_at?: string | null;
        readonly folder_id?: string | null;
        readonly id: string;
        readonly metadata?: Record<string, any> | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
    }>;
  } | null;
};

export type DeleteOneBookmarkFolderMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneBookmarkFolderMutationQuery = {
  readonly delete_bookmark_folders_by_pk?: {
    readonly color?: string | null;
    readonly created_at?: string | null;
    readonly id: string;
    readonly is_default?: boolean | null;
    readonly is_favorite?: boolean | null;
    readonly name: string;
    readonly parent_id?: string | null;
    readonly path?: any | null;
    readonly position?: number | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly bookmarks: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly folder_id?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  } | null;
};

export type DeleteManyBookmarkMutationVariables = Exact<{
  where: BookmarksBoolExp;
}>;

export type DeleteManyBookmarkMutationQuery = {
  readonly delete_bookmarks?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly folder_id?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly bookmark_folder?: {
        readonly color?: string | null;
        readonly created_at?: string | null;
        readonly id: string;
        readonly is_default?: boolean | null;
        readonly is_favorite?: boolean | null;
        readonly name: string;
        readonly parent_id?: string | null;
        readonly path?: any | null;
        readonly position?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      } | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null;
};

export type DeleteOneBookmarkMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneBookmarkMutationQuery = {
  readonly delete_bookmarks_by_pk?: {
    readonly content_id: string;
    readonly content_type: string;
    readonly created_at?: string | null;
    readonly folder_id?: string | null;
    readonly id: string;
    readonly metadata?: Record<string, any> | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly bookmark_folder?: {
      readonly color?: string | null;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_default?: boolean | null;
      readonly is_favorite?: boolean | null;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly path?: any | null;
      readonly position?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    } | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type DeleteManyBusinessDomainMutationVariables = Exact<{
  where: BusinessDomainsBoolExp;
}>;

export type DeleteManyBusinessDomainMutationQuery = {
  readonly delete_business_domains?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly id: string;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly slug: string;
      readonly updated_at?: string | null;
      readonly categorized_urls: ReadonlyArray<{
        readonly categorizer_version: string;
        readonly company_id?: string | null;
        readonly confidence: number;
        readonly content_hash?: string | null;
        readonly created_at?: string | null;
        readonly domain_id: string;
        readonly found_on?: string | null;
        readonly id: string;
        readonly priority?: any | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
    }>;
  } | null;
};

export type DeleteOneBusinessDomainMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneBusinessDomainMutationQuery = {
  readonly delete_business_domains_by_pk?: {
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly id: string;
    readonly name: string;
    readonly parent_id?: string | null;
    readonly slug: string;
    readonly updated_at?: string | null;
    readonly categorized_urls: ReadonlyArray<{
      readonly categorizer_version: string;
      readonly company_id?: string | null;
      readonly confidence: number;
      readonly content_hash?: string | null;
      readonly created_at?: string | null;
      readonly domain_id: string;
      readonly found_on?: string | null;
      readonly id: string;
      readonly priority?: any | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
  } | null;
};

export type DeleteManyCategoryMutationVariables = Exact<{
  where: CategoriesBoolExp;
}>;

export type DeleteManyCategoryMutationQuery = {
  readonly delete_categories?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
      readonly companies: ReadonlyArray<{
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
      readonly content_categories: ReadonlyArray<{
        readonly category_id: number;
        readonly content_id: string;
        readonly is_primary: boolean;
      }>;
      readonly feed_categories: ReadonlyArray<{
        readonly category_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly news: ReadonlyArray<{
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
    }>;
  } | null;
};

export type DeleteOneCategoryMutationVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneCategoryMutationQuery = {
  readonly delete_categories_by_pk?: {
    readonly body?: string | null;
    readonly created_at: string;
    readonly document_id?: string | null;
    readonly id: number;
    readonly locale?: string | null;
    readonly name: string;
    readonly published_at?: string | null;
    readonly updated_at?: string | null;
    readonly companies: ReadonlyArray<{
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
    readonly content_categories: ReadonlyArray<{
      readonly category_id: number;
      readonly content_id: string;
      readonly is_primary: boolean;
    }>;
    readonly feed_categories: ReadonlyArray<{
      readonly category_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly news: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
  } | null;
};

export type DeleteManyCategorizedUrlMutationVariables = Exact<{
  where: CategorizedUrlsBoolExp;
}>;

export type DeleteManyCategorizedUrlMutationQuery = {
  readonly delete_categorized_urls?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly categorizer_version: string;
      readonly company_id?: string | null;
      readonly confidence: number;
      readonly content_hash?: string | null;
      readonly created_at?: string | null;
      readonly domain_id: string;
      readonly found_on?: string | null;
      readonly id: string;
      readonly priority?: any | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly business_domain: {
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly id: string;
        readonly name: string;
        readonly parent_id?: string | null;
        readonly slug: string;
        readonly updated_at?: string | null;
      };
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null;
};

export type DeleteOneCategorizedUrlMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneCategorizedUrlMutationQuery = {
  readonly delete_categorized_urls_by_pk?: {
    readonly categorizer_version: string;
    readonly company_id?: string | null;
    readonly confidence: number;
    readonly content_hash?: string | null;
    readonly created_at?: string | null;
    readonly domain_id: string;
    readonly found_on?: string | null;
    readonly id: string;
    readonly priority?: any | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly business_domain: {
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly id: string;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly slug: string;
      readonly updated_at?: string | null;
    };
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type DeleteManyCircuitBreakerStateMutationVariables = Exact<{
  where: CircuitBreakerStatesBoolExp;
}>;

export type DeleteManyCircuitBreakerStateMutationQuery = {
  readonly delete_circuit_breaker_states?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly failure_count?: number | null;
      readonly id: string;
      readonly job_name: string;
      readonly last_failure?: string | null;
      readonly last_success?: string | null;
      readonly state: string;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type DeleteOneCircuitBreakerStateMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneCircuitBreakerStateMutationQuery = {
  readonly delete_circuit_breaker_states_by_pk?: {
    readonly created_at?: string | null;
    readonly failure_count?: number | null;
    readonly id: string;
    readonly job_name: string;
    readonly last_failure?: string | null;
    readonly last_success?: string | null;
    readonly state: string;
    readonly updated_at?: string | null;
  } | null;
};

export type DeleteManyCityMutationVariables = Exact<{
  where: CitiesBoolExp;
}>;

export type DeleteManyCityMutationQuery = {
  readonly delete_cities?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly country_id: number;
      readonly id: number;
      readonly name: string;
      readonly state?: string | null;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly country: {
        readonly code: string;
        readonly code_3?: string | null;
        readonly id: number;
        readonly name: string;
      };
    }>;
  } | null;
};

export type DeleteOneCityMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCityMutationQuery = {
  readonly delete_cities_by_pk?: {
    readonly country_id: number;
    readonly id: number;
    readonly name: string;
    readonly state?: string | null;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly country: {
      readonly code: string;
      readonly code_3?: string | null;
      readonly id: number;
      readonly name: string;
    };
  } | null;
};

export type DeleteManyCommentMutationVariables = Exact<{
  where: CommentsBoolExp;
}>;

export type DeleteManyCommentMutationQuery = {
  readonly delete_comments?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content: string;
      readonly content_id: string;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly parent_comment_id?: string | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneCommentMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneCommentMutationQuery = {
  readonly delete_comments_by_pk?: {
    readonly content: string;
    readonly content_id: string;
    readonly content_type: any;
    readonly created_at?: string | null;
    readonly id: string;
    readonly parent_comment_id?: string | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type DeleteManyCompanyMutationVariables = Exact<{
  where: CompaniesBoolExp;
}>;

export type DeleteManyCompanyMutationQuery = {
  readonly delete_companies?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly ads: ReadonlyArray<{
        readonly active?: boolean | null;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly id: string;
        readonly package_id?: string | null;
        readonly start_date: string;
        readonly updated_at?: string | null;
      }>;
      readonly blacklisted_urls: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly id: number;
        readonly reason?: string | null;
        readonly url: string;
      }>;
      readonly categorized_urls: ReadonlyArray<{
        readonly categorizer_version: string;
        readonly company_id?: string | null;
        readonly confidence: number;
        readonly content_hash?: string | null;
        readonly created_at?: string | null;
        readonly domain_id: string;
        readonly found_on?: string | null;
        readonly id: string;
        readonly priority?: any | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
      readonly categoryByCategoryId?: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly company_contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_id: number;
        readonly created_at: string;
        readonly id: number;
        readonly updated_at: string;
      }>;
      readonly company_extras: ReadonlyArray<{
        readonly body?: string | null;
        readonly category: string;
        readonly company_id?: string | null;
        readonly created_at: string;
        readonly found_count?: number | null;
        readonly id: number;
        readonly level: any;
        readonly review?: Record<string, any> | null;
        readonly success?: boolean | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
      readonly contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_type?: any | null;
        readonly created_at?: string | null;
        readonly email?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly phone?: string | null;
        readonly privacy_level?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly content_sources: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly expected_count?: any | null;
        readonly failed_count?: any | null;
        readonly has_failed?: boolean | null;
        readonly hash?: number | null;
        readonly id: number;
        readonly priority: any;
        readonly refreshed_at?: string | null;
        readonly rss_urls?: ReadonlyArray<string> | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
      readonly news: ReadonlyArray<{
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
      readonly social_medium?: {
        readonly created_at?: string | null;
        readonly facebook_url?: string | null;
        readonly id: number;
        readonly instagram_url?: string | null;
        readonly linkedin_url?: string | null;
        readonly twitter_url?: string | null;
        readonly updated_at?: string | null;
        readonly youtube_url?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneCompanyMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneCompanyMutationQuery = {
  readonly delete_companies_by_pk?: {
    readonly category?: string | null;
    readonly category_id?: number | null;
    readonly content_status: any;
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly failed_count?: any | null;
    readonly founding_year?: any | null;
    readonly id: string;
    readonly is_english?: boolean | null;
    readonly is_government?: boolean | null;
    readonly keywords?: Record<string, any> | null;
    readonly logo_url?: string | null;
    readonly name?: string | null;
    readonly scrape_frequency?: any | null;
    readonly scrape_rating?: any | null;
    readonly scraped_at?: string | null;
    readonly social_media_id?: number | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly ads: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    }>;
    readonly blacklisted_urls: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly id: number;
      readonly reason?: string | null;
      readonly url: string;
    }>;
    readonly categorized_urls: ReadonlyArray<{
      readonly categorizer_version: string;
      readonly company_id?: string | null;
      readonly confidence: number;
      readonly content_hash?: string | null;
      readonly created_at?: string | null;
      readonly domain_id: string;
      readonly found_on?: string | null;
      readonly id: string;
      readonly priority?: any | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
    readonly categoryByCategoryId?: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly company_contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_id: number;
      readonly created_at: string;
      readonly id: number;
      readonly updated_at: string;
    }>;
    readonly company_extras: ReadonlyArray<{
      readonly body?: string | null;
      readonly category: string;
      readonly company_id?: string | null;
      readonly created_at: string;
      readonly found_count?: number | null;
      readonly id: number;
      readonly level: any;
      readonly review?: Record<string, any> | null;
      readonly success?: boolean | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
    readonly contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly content_sources: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
    readonly news: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
    readonly social_medium?: {
      readonly created_at?: string | null;
      readonly facebook_url?: string | null;
      readonly id: number;
      readonly instagram_url?: string | null;
      readonly linkedin_url?: string | null;
      readonly twitter_url?: string | null;
      readonly updated_at?: string | null;
      readonly youtube_url?: string | null;
    } | null;
  } | null;
};

export type DeleteManyCompanyContactMutationVariables = Exact<{
  where: CompanyContactsBoolExp;
}>;

export type DeleteManyCompanyContactMutationQuery = {
  readonly delete_company_contacts?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_id: number;
      readonly created_at: string;
      readonly id: number;
      readonly updated_at: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly contact: {
        readonly company_id?: string | null;
        readonly contact_type?: any | null;
        readonly created_at?: string | null;
        readonly email?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly phone?: string | null;
        readonly privacy_level?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneCompanyContactMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCompanyContactMutationQuery = {
  readonly delete_company_contacts_by_pk?: {
    readonly company_id?: string | null;
    readonly contact_id: number;
    readonly created_at: string;
    readonly id: number;
    readonly updated_at: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly contact: {
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    };
  } | null;
};

export type DeleteManyCompanyEmployeeMutationVariables = Exact<{
  where: CompanyEmployeesBoolExp;
}>;

export type DeleteManyCompanyEmployeeMutationQuery = {
  readonly delete_company_employees?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly access_level: any;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date?: string | null;
      readonly id: string;
      readonly job_description?: string | null;
      readonly role: string;
      readonly start_date?: string | null;
      readonly status?: boolean | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneCompanyEmployeeMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneCompanyEmployeeMutationQuery = {
  readonly delete_company_employees_by_pk?: {
    readonly access_level: any;
    readonly company_id?: string | null;
    readonly created_at?: string | null;
    readonly end_date?: string | null;
    readonly id: string;
    readonly job_description?: string | null;
    readonly role: string;
    readonly start_date?: string | null;
    readonly status?: boolean | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type DeleteManyCompanyExtraMutationVariables = Exact<{
  where: CompanyExtrasBoolExp;
}>;

export type DeleteManyCompanyExtraMutationQuery = {
  readonly delete_company_extras?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly body?: string | null;
      readonly category: string;
      readonly company_id?: string | null;
      readonly created_at: string;
      readonly found_count?: number | null;
      readonly id: number;
      readonly level: any;
      readonly review?: Record<string, any> | null;
      readonly success?: boolean | null;
      readonly updated_at: string;
      readonly url: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null;
};

export type DeleteOneCompanyExtraMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCompanyExtraMutationQuery = {
  readonly delete_company_extras_by_pk?: {
    readonly body?: string | null;
    readonly category: string;
    readonly company_id?: string | null;
    readonly created_at: string;
    readonly found_count?: number | null;
    readonly id: number;
    readonly level: any;
    readonly review?: Record<string, any> | null;
    readonly success?: boolean | null;
    readonly updated_at: string;
    readonly url: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type DeleteManyCompanyMetricMutationVariables = Exact<{
  where: CompanyMetricsBoolExp;
}>;

export type DeleteManyCompanyMetricMutationQuery = {
  readonly delete_company_metrics?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id: string;
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
      readonly metric_definition?: {
        readonly category?: string | null;
        readonly description?: string | null;
        readonly id: number;
        readonly is_dimensional?: boolean | null;
        readonly name: string;
        readonly type: string;
        readonly unit?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneCompanyMetricMutationVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneCompanyMetricMutationQuery = {
  readonly delete_company_metrics_by_pk?: {
    readonly company_id: string;
    readonly crawl_id: string;
    readonly id: number;
    readonly metric_id?: number | null;
    readonly timestamp: string;
    readonly value: Record<string, any>;
    readonly metric_definition?: {
      readonly category?: string | null;
      readonly description?: string | null;
      readonly id: number;
      readonly is_dimensional?: boolean | null;
      readonly name: string;
      readonly type: string;
      readonly unit?: string | null;
    } | null;
  } | null;
};

export type DeleteManyContactMutationVariables = Exact<{
  where: ContactsBoolExp;
}>;

export type DeleteManyContactMutationQuery = {
  readonly delete_contacts?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly company_contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_id: number;
        readonly created_at: string;
        readonly id: number;
        readonly updated_at: string;
      }>;
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneContactMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneContactMutationQuery = {
  readonly delete_contacts_by_pk?: {
    readonly company_id?: string | null;
    readonly contact_type?: any | null;
    readonly created_at?: string | null;
    readonly email?: string | null;
    readonly id: number;
    readonly is_primary?: boolean | null;
    readonly phone?: string | null;
    readonly privacy_level?: any | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly user_id?: string | null;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly company_contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_id: number;
      readonly created_at: string;
      readonly id: number;
      readonly updated_at: string;
    }>;
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type DeleteManyContentCategoryMutationVariables = Exact<{
  where: ContentCategoriesBoolExp;
}>;

export type DeleteManyContentCategoryMutationQuery = {
  readonly delete_content_categories?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category_id: number;
      readonly content_id: string;
      readonly is_primary: boolean;
      readonly category: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      };
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null;
};

export type DeleteOneContentCategoryMutationVariables = Exact<{
  category_id: Scalars["bigint"]["input"];
  content_id: Scalars["uuid"]["input"];
}>;

export type DeleteOneContentCategoryMutationQuery = {
  readonly delete_content_categories_by_pk?: {
    readonly category_id: number;
    readonly content_id: string;
    readonly is_primary: boolean;
    readonly category: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    };
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type DeleteManyContentSourceVisitMutationVariables = Exact<{
  where: ContentSourceVisitsBoolExp;
}>;

export type DeleteManyContentSourceVisitMutationQuery = {
  readonly delete_content_source_visits?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneContentSourceVisitMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneContentSourceVisitMutationQuery = {
  readonly delete_content_source_visits_by_pk?: {
    readonly content_id: string;
    readonly created_at?: string | null;
    readonly id: string;
    readonly user_id?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type DeleteManyContentSourceMutationVariables = Exact<{
  where: ContentSourcesBoolExp;
}>;

export type DeleteManyContentSourceMutationQuery = {
  readonly delete_content_sources?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly feed_sources: ReadonlyArray<{
        readonly content_source_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly news: ReadonlyArray<{
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
    }>;
  } | null;
};

export type DeleteOneContentSourceMutationVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneContentSourceMutationQuery = {
  readonly delete_content_sources_by_pk?: {
    readonly company_id?: string | null;
    readonly content_type: any;
    readonly created_at?: string | null;
    readonly expected_count?: any | null;
    readonly failed_count?: any | null;
    readonly has_failed?: boolean | null;
    readonly hash?: number | null;
    readonly id: number;
    readonly priority: any;
    readonly refreshed_at?: string | null;
    readonly rss_urls?: ReadonlyArray<string> | null;
    readonly scrape_frequency: any;
    readonly scraped_at?: string | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly feed_sources: ReadonlyArray<{
      readonly content_source_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly news: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
  } | null;
};

export type DeleteManyContentStatusMutationVariables = Exact<{
  where: ContentStatusesBoolExp;
}>;

export type DeleteManyContentStatusMutationQuery = {
  readonly delete_content_statuses?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly notes?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null;
};

export type DeleteOneContentStatusMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneContentStatusMutationQuery = {
  readonly delete_content_statuses_by_pk?: {
    readonly content_id: string;
    readonly content_status: any;
    readonly created_at?: string | null;
    readonly id: string;
    readonly notes?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type DeleteManyContentTagMutationVariables = Exact<{
  where: ContentTagsBoolExp;
}>;

export type DeleteManyContentTagMutationQuery = {
  readonly delete_content_tags?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly tag_id: number;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly tag: {
        readonly body?: string | null;
        readonly created_at?: string | null;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneContentTagMutationVariables = Exact<{
  content_id: Scalars["uuid"]["input"];
  tag_id: Scalars["Int"]["input"];
}>;

export type DeleteOneContentTagMutationQuery = {
  readonly delete_content_tags_by_pk?: {
    readonly content_id: string;
    readonly tag_id: number;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly tag: {
      readonly body?: string | null;
      readonly created_at?: string | null;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    };
  } | null;
};

export type DeleteManyContentMutationVariables = Exact<{
  where: ContentsBoolExp;
}>;

export type DeleteManyContentMutationQuery = {
  readonly delete_contents?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly bookmarks: ReadonlyArray<{
        readonly content_id: string;
        readonly content_type: string;
        readonly created_at?: string | null;
        readonly folder_id?: string | null;
        readonly id: string;
        readonly metadata?: Record<string, any> | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly content_categories: ReadonlyArray<{
        readonly category_id: number;
        readonly content_id: string;
        readonly is_primary: boolean;
      }>;
      readonly content_source_visits: ReadonlyArray<{
        readonly content_id: string;
        readonly created_at?: string | null;
        readonly id: string;
        readonly user_id?: string | null;
      }>;
      readonly content_statuses: ReadonlyArray<{
        readonly content_id: string;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly id: string;
        readonly notes?: string | null;
      }>;
      readonly content_tags: ReadonlyArray<{
        readonly content_id: string;
        readonly tag_id: number;
      }>;
      readonly news?: {
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      } | null;
      readonly newsletter?: {
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly frequency: string;
        readonly generated_content?: string | null;
        readonly id: string;
        readonly start_date: string;
        readonly title: string;
        readonly updated_at?: string | null;
      } | null;
      readonly research?: {
        readonly abstract?: string | null;
        readonly abstract_url: string;
        readonly affiliations?: Record<string, any> | null;
        readonly authors?: Record<string, any> | null;
        readonly category?: string | null;
        readonly comments?: string | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly doi_url?: string | null;
        readonly figure_count?: any | null;
        readonly has_embedding?: boolean | null;
        readonly id: string;
        readonly is_flagged: boolean;
        readonly keywords?: string | null;
        readonly month?: string | null;
        readonly page_count?: any | null;
        readonly pdf_url?: string | null;
        readonly published_at?: string | null;
        readonly published_in?: string | null;
        readonly summary?: string | null;
        readonly table_count?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly version?: any | null;
        readonly year?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneContentMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneContentMutationQuery = {
  readonly delete_contents_by_pk?: {
    readonly content_type: any;
    readonly created_at?: string | null;
    readonly hot_score?: any | null;
    readonly id: string;
    readonly rss_url?: string | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly bookmarks: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly folder_id?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly content_categories: ReadonlyArray<{
      readonly category_id: number;
      readonly content_id: string;
      readonly is_primary: boolean;
    }>;
    readonly content_source_visits: ReadonlyArray<{
      readonly content_id: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id?: string | null;
    }>;
    readonly content_statuses: ReadonlyArray<{
      readonly content_id: string;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly notes?: string | null;
    }>;
    readonly content_tags: ReadonlyArray<{
      readonly content_id: string;
      readonly tag_id: number;
    }>;
    readonly news?: {
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    } | null;
    readonly newsletter?: {
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly frequency: string;
      readonly generated_content?: string | null;
      readonly id: string;
      readonly start_date: string;
      readonly title: string;
      readonly updated_at?: string | null;
    } | null;
    readonly research?: {
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
    } | null;
  } | null;
};

export type DeleteManyCountryMutationVariables = Exact<{
  where: CountriesBoolExp;
}>;

export type DeleteManyCountryMutationQuery = {
  readonly delete_countries?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly code: string;
      readonly code_3?: string | null;
      readonly id: number;
      readonly name: string;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly cities: ReadonlyArray<{
        readonly country_id: number;
        readonly id: number;
        readonly name: string;
        readonly state?: string | null;
      }>;
    }>;
  } | null;
};

export type DeleteOneCountryMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCountryMutationQuery = {
  readonly delete_countries_by_pk?: {
    readonly code: string;
    readonly code_3?: string | null;
    readonly id: number;
    readonly name: string;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly cities: ReadonlyArray<{
      readonly country_id: number;
      readonly id: number;
      readonly name: string;
      readonly state?: string | null;
    }>;
  } | null;
};

export type DeleteManyCustomerPaymentMutationVariables = Exact<{
  where: CustomerPaymentsBoolExp;
}>;

export type DeleteManyCustomerPaymentMutationQuery = {
  readonly delete_customer_payments?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
      readonly customer_refunds: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly batch_id?: string | null;
        readonly created_at?: string | null;
        readonly currency?: string | null;
        readonly external_refund_id: string;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly payment_id: number;
        readonly receipt?: string | null;
        readonly speed_processed?: string | null;
        readonly speed_requested?: string | null;
        readonly status: string;
      }>;
      readonly customer_subscription?: {
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      } | null;
      readonly payment_provider: {
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_active?: boolean | null;
        readonly name: string;
        readonly updated_at?: string | null;
      };
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneCustomerPaymentMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCustomerPaymentMutationQuery = {
  readonly delete_customer_payments_by_pk?: {
    readonly acquirer_data?: Record<string, any> | null;
    readonly amount: number;
    readonly amount_refunded?: number | null;
    readonly amount_transferred?: number | null;
    readonly bank?: string | null;
    readonly captured?: boolean | null;
    readonly created_at?: string | null;
    readonly currency: string;
    readonly description?: string | null;
    readonly error_code?: string | null;
    readonly error_description?: string | null;
    readonly error_reason?: string | null;
    readonly error_source?: string | null;
    readonly error_step?: string | null;
    readonly external_order_id?: string | null;
    readonly external_payment_id: string;
    readonly fee?: number | null;
    readonly id: number;
    readonly international?: boolean | null;
    readonly invoice_id?: string | null;
    readonly method?: string | null;
    readonly notes?: Record<string, any> | null;
    readonly order_id?: string | null;
    readonly payment_provider_id: number;
    readonly refund_status?: string | null;
    readonly status: string;
    readonly subscription_id?: number | null;
    readonly tax?: number | null;
    readonly user_id: string;
    readonly vpa?: string | null;
    readonly wallet?: string | null;
    readonly customer_refunds: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly batch_id?: string | null;
      readonly created_at?: string | null;
      readonly currency?: string | null;
      readonly external_refund_id: string;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly payment_id: number;
      readonly receipt?: string | null;
      readonly speed_processed?: string | null;
      readonly speed_requested?: string | null;
      readonly status: string;
    }>;
    readonly customer_subscription?: {
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    } | null;
    readonly payment_provider: {
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_active?: boolean | null;
      readonly name: string;
      readonly updated_at?: string | null;
    };
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type DeleteManyCustomerProcessedWebhookMutationVariables = Exact<{
  where: CustomerProcessedWebhooksBoolExp;
}>;

export type DeleteManyCustomerProcessedWebhookMutationQuery = {
  readonly delete_customer_processed_webhooks?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly event_id: string;
      readonly event_type: string;
      readonly id: number;
      readonly processed_at: string;
    }>;
  } | null;
};

export type DeleteOneCustomerProcessedWebhookMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCustomerProcessedWebhookMutationQuery = {
  readonly delete_customer_processed_webhooks_by_pk?: {
    readonly event_id: string;
    readonly event_type: string;
    readonly id: number;
    readonly processed_at: string;
  } | null;
};

export type DeleteManyCustomerRefundMutationVariables = Exact<{
  where: CustomerRefundsBoolExp;
}>;

export type DeleteManyCustomerRefundMutationQuery = {
  readonly delete_customer_refunds?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly batch_id?: string | null;
      readonly created_at?: string | null;
      readonly currency?: string | null;
      readonly external_refund_id: string;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly payment_id: number;
      readonly receipt?: string | null;
      readonly speed_processed?: string | null;
      readonly speed_requested?: string | null;
      readonly status: string;
      readonly customer_payment: {
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneCustomerRefundMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCustomerRefundMutationQuery = {
  readonly delete_customer_refunds_by_pk?: {
    readonly acquirer_data?: Record<string, any> | null;
    readonly amount: number;
    readonly batch_id?: string | null;
    readonly created_at?: string | null;
    readonly currency?: string | null;
    readonly external_refund_id: string;
    readonly id: number;
    readonly notes?: Record<string, any> | null;
    readonly payment_id: number;
    readonly receipt?: string | null;
    readonly speed_processed?: string | null;
    readonly speed_requested?: string | null;
    readonly status: string;
    readonly customer_payment: {
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    };
  } | null;
};

export type DeleteManyCustomerSubscriptionPlanMutationVariables = Exact<{
  where: CustomerSubscriptionPlansBoolExp;
}>;

export type DeleteManyCustomerSubscriptionPlanMutationQuery = {
  readonly delete_customer_subscription_plans?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly annual_amount: number;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly external_plan_id?: string | null;
      readonly features?: Record<string, any> | null;
      readonly id: number;
      readonly interval: number;
      readonly interval_type: string;
      readonly is_active?: boolean | null;
      readonly monthly_amount: number;
      readonly name: string;
      readonly updated_at?: string | null;
      readonly customer_subscriptions: ReadonlyArray<{
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
    }>;
  } | null;
};

export type DeleteOneCustomerSubscriptionPlanMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCustomerSubscriptionPlanMutationQuery = {
  readonly delete_customer_subscription_plans_by_pk?: {
    readonly annual_amount: number;
    readonly created_at?: string | null;
    readonly currency: string;
    readonly description?: string | null;
    readonly external_plan_id?: string | null;
    readonly features?: Record<string, any> | null;
    readonly id: number;
    readonly interval: number;
    readonly interval_type: string;
    readonly is_active?: boolean | null;
    readonly monthly_amount: number;
    readonly name: string;
    readonly updated_at?: string | null;
    readonly customer_subscriptions: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  } | null;
};

export type DeleteManyCustomerSubscriptionMutationVariables = Exact<{
  where: CustomerSubscriptionsBoolExp;
}>;

export type DeleteManyCustomerSubscriptionMutationQuery = {
  readonly delete_customer_subscriptions?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly customer_payments: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      }>;
      readonly customer_subscription_plan: {
        readonly annual_amount: number;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly external_plan_id?: string | null;
        readonly features?: Record<string, any> | null;
        readonly id: number;
        readonly interval: number;
        readonly interval_type: string;
        readonly is_active?: boolean | null;
        readonly monthly_amount: number;
        readonly name: string;
        readonly updated_at?: string | null;
      };
      readonly payment_provider: {
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_active?: boolean | null;
        readonly name: string;
        readonly updated_at?: string | null;
      };
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneCustomerSubscriptionMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneCustomerSubscriptionMutationQuery = {
  readonly delete_customer_subscriptions_by_pk?: {
    readonly auth_attempts?: number | null;
    readonly cancel_at_period_end?: boolean | null;
    readonly cancel_initiated_by?: string | null;
    readonly change_scheduled_at?: string | null;
    readonly charge_at?: string | null;
    readonly created_at?: string | null;
    readonly current_end: string;
    readonly current_start: string;
    readonly customer_notify?: boolean | null;
    readonly end_at?: string | null;
    readonly ended_at?: string | null;
    readonly expire_by?: string | null;
    readonly external_subscription_id: string;
    readonly has_scheduled_changes?: boolean | null;
    readonly id: number;
    readonly notes?: Record<string, any> | null;
    readonly offer_id?: string | null;
    readonly paid_count?: number | null;
    readonly pause_initiated_by?: string | null;
    readonly payment_provider_id: number;
    readonly plan_id: number;
    readonly quantity?: number | null;
    readonly remaining_count?: number | null;
    readonly short_url?: string | null;
    readonly source?: string | null;
    readonly start_at?: string | null;
    readonly status: string;
    readonly total_count?: number | null;
    readonly type?: number | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly customer_payments: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
    readonly customer_subscription_plan: {
      readonly annual_amount: number;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly external_plan_id?: string | null;
      readonly features?: Record<string, any> | null;
      readonly id: number;
      readonly interval: number;
      readonly interval_type: string;
      readonly is_active?: boolean | null;
      readonly monthly_amount: number;
      readonly name: string;
      readonly updated_at?: string | null;
    };
    readonly payment_provider: {
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_active?: boolean | null;
      readonly name: string;
      readonly updated_at?: string | null;
    };
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type DeleteManyEmbeddingReviewMutationVariables = Exact<{
  where: EmbeddingReviewsBoolExp;
}>;

export type DeleteManyEmbeddingReviewMutationQuery = {
  readonly delete_embedding_reviews?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly agent_review?: boolean | null;
      readonly created_at: string;
      readonly human_review?: boolean | null;
      readonly id: number;
      readonly notes?: string | null;
      readonly updated_at?: string | null;
      readonly research_embeddings: ReadonlyArray<{
        readonly chunk: string;
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly embedding_review_id?: number | null;
        readonly id: number;
        readonly is_flagged?: boolean | null;
        readonly research_id: string;
        readonly updated_at: string;
        readonly url?: string | null;
      }>;
    }>;
  } | null;
};

export type DeleteOneEmbeddingReviewMutationVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneEmbeddingReviewMutationQuery = {
  readonly delete_embedding_reviews_by_pk?: {
    readonly agent_review?: boolean | null;
    readonly created_at: string;
    readonly human_review?: boolean | null;
    readonly id: number;
    readonly notes?: string | null;
    readonly updated_at?: string | null;
    readonly research_embeddings: ReadonlyArray<{
      readonly chunk: string;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly embedding_review_id?: number | null;
      readonly id: number;
      readonly is_flagged?: boolean | null;
      readonly research_id: string;
      readonly updated_at: string;
      readonly url?: string | null;
    }>;
  } | null;
};

export type DeleteManyErrorLogMutationVariables = Exact<{
  where: ErrorLogsBoolExp;
}>;

export type DeleteManyErrorLogMutationQuery = {
  readonly delete_error_logs?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly context?: Record<string, any> | null;
      readonly correlation_id?: string | null;
      readonly created_at?: string | null;
      readonly domain?: string | null;
      readonly environment: string;
      readonly error_hash?: string | null;
      readonly error_pattern?: string | null;
      readonly error_type: any;
      readonly frequency_data?: Record<string, any> | null;
      readonly github_repo?: string | null;
      readonly id: string;
      readonly is_new_pattern?: boolean | null;
      readonly message: string;
      readonly metadata?: Record<string, any> | null;
      readonly related_errors?: Record<string, any> | null;
      readonly request_id?: string | null;
      readonly service_name: string;
      readonly severity: any;
      readonly stack_trace?: string | null;
      readonly user_id?: string | null;
    }>;
  } | null;
};

export type DeleteOneErrorLogMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneErrorLogMutationQuery = {
  readonly delete_error_logs_by_pk?: {
    readonly context?: Record<string, any> | null;
    readonly correlation_id?: string | null;
    readonly created_at?: string | null;
    readonly domain?: string | null;
    readonly environment: string;
    readonly error_hash?: string | null;
    readonly error_pattern?: string | null;
    readonly error_type: any;
    readonly frequency_data?: Record<string, any> | null;
    readonly github_repo?: string | null;
    readonly id: string;
    readonly is_new_pattern?: boolean | null;
    readonly message: string;
    readonly metadata?: Record<string, any> | null;
    readonly related_errors?: Record<string, any> | null;
    readonly request_id?: string | null;
    readonly service_name: string;
    readonly severity: any;
    readonly stack_trace?: string | null;
    readonly user_id?: string | null;
  } | null;
};

export type DeleteManyFeatureRequestMutationVariables = Exact<{
  where: FeatureRequestsBoolExp;
}>;

export type DeleteManyFeatureRequestMutationQuery = {
  readonly delete_feature_requests?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly downvotes?: number | null;
      readonly engagement_score?: number | null;
      readonly id: string;
      readonly priority_score?: number | null;
      readonly status: string;
      readonly title: string;
      readonly updated_at?: string | null;
      readonly upvotes?: number | null;
      readonly feature_votes: ReadonlyArray<{
        readonly created_at?: string | null;
        readonly feature_id: string;
        readonly feedback?: string | null;
        readonly id: string;
        readonly updated_at?: string | null;
        readonly user_id: string;
        readonly vote_type: any;
      }>;
    }>;
  } | null;
};

export type DeleteOneFeatureRequestMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneFeatureRequestMutationQuery = {
  readonly delete_feature_requests_by_pk?: {
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly downvotes?: number | null;
    readonly engagement_score?: number | null;
    readonly id: string;
    readonly priority_score?: number | null;
    readonly status: string;
    readonly title: string;
    readonly updated_at?: string | null;
    readonly upvotes?: number | null;
    readonly feature_votes: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly feature_id: string;
      readonly feedback?: string | null;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly vote_type: any;
    }>;
  } | null;
};

export type DeleteManyFeatureVoteMutationVariables = Exact<{
  where: FeatureVotesBoolExp;
}>;

export type DeleteManyFeatureVoteMutationQuery = {
  readonly delete_feature_votes?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly feature_id: string;
      readonly feedback?: string | null;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly vote_type: any;
      readonly feature_request: {
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly downvotes?: number | null;
        readonly engagement_score?: number | null;
        readonly id: string;
        readonly priority_score?: number | null;
        readonly status: string;
        readonly title: string;
        readonly updated_at?: string | null;
        readonly upvotes?: number | null;
      };
    }>;
  } | null;
};

export type DeleteOneFeatureVoteMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneFeatureVoteMutationQuery = {
  readonly delete_feature_votes_by_pk?: {
    readonly created_at?: string | null;
    readonly feature_id: string;
    readonly feedback?: string | null;
    readonly id: string;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly vote_type: any;
    readonly feature_request: {
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly downvotes?: number | null;
      readonly engagement_score?: number | null;
      readonly id: string;
      readonly priority_score?: number | null;
      readonly status: string;
      readonly title: string;
      readonly updated_at?: string | null;
      readonly upvotes?: number | null;
    };
  } | null;
};

export type DeleteManyFeedCategoryMutationVariables = Exact<{
  where: FeedCategoriesBoolExp;
}>;

export type DeleteManyFeedCategoryMutationQuery = {
  readonly delete_feed_categories?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
      readonly category?: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly feed?: {
        readonly created_at: string;
        readonly id: string;
        readonly name?: string | null;
        readonly user_id?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneFeedCategoryMutationVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneFeedCategoryMutationQuery = {
  readonly delete_feed_categories_by_pk?: {
    readonly category_id?: number | null;
    readonly created_at: string;
    readonly feed_id?: string | null;
    readonly id: number;
    readonly category?: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly feed?: {
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    } | null;
  } | null;
};

export type DeleteManyFeedSourceMutationVariables = Exact<{
  where: FeedSourcesBoolExp;
}>;

export type DeleteManyFeedSourceMutationQuery = {
  readonly delete_feed_sources?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_source_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
      readonly content_source?: {
        readonly company_id?: string | null;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly expected_count?: any | null;
        readonly failed_count?: any | null;
        readonly has_failed?: boolean | null;
        readonly hash?: number | null;
        readonly id: number;
        readonly priority: any;
        readonly refreshed_at?: string | null;
        readonly rss_urls?: ReadonlyArray<string> | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly feed?: {
        readonly created_at: string;
        readonly id: string;
        readonly name?: string | null;
        readonly user_id?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneFeedSourceMutationVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneFeedSourceMutationQuery = {
  readonly delete_feed_sources_by_pk?: {
    readonly content_source_id?: number | null;
    readonly created_at: string;
    readonly feed_id?: string | null;
    readonly id: number;
    readonly content_source?: {
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly feed?: {
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    } | null;
  } | null;
};

export type DeleteManyFeedbackMutationVariables = Exact<{
  where: FeedbacksBoolExp;
}>;

export type DeleteManyFeedbackMutationQuery = {
  readonly delete_feedbacks?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at: string;
      readonly device_info?: string | null;
      readonly feedback_status?: any | null;
      readonly feedback_type?: any | null;
      readonly id: number;
      readonly message: string;
      readonly page_identifier: string;
      readonly rating?: number | null;
      readonly resolution_comment?: string | null;
      readonly updated_at: string;
      readonly user_id?: string | null;
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneFeedbackMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneFeedbackMutationQuery = {
  readonly delete_feedbacks_by_pk?: {
    readonly created_at: string;
    readonly device_info?: string | null;
    readonly feedback_status?: any | null;
    readonly feedback_type?: any | null;
    readonly id: number;
    readonly message: string;
    readonly page_identifier: string;
    readonly rating?: number | null;
    readonly resolution_comment?: string | null;
    readonly updated_at: string;
    readonly user_id?: string | null;
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type DeleteManyFeedMutationVariables = Exact<{
  where: FeedsBoolExp;
}>;

export type DeleteManyFeedMutationQuery = {
  readonly delete_feeds?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
      readonly feed_categories: ReadonlyArray<{
        readonly category_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly feed_sources: ReadonlyArray<{
        readonly content_source_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneFeedMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneFeedMutationQuery = {
  readonly delete_feeds_by_pk?: {
    readonly created_at: string;
    readonly id: string;
    readonly name?: string | null;
    readonly user_id?: string | null;
    readonly feed_categories: ReadonlyArray<{
      readonly category_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly feed_sources: ReadonlyArray<{
      readonly content_source_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type DeleteManyFollowMutationVariables = Exact<{
  where: FollowsBoolExp;
}>;

export type DeleteManyFollowMutationQuery = {
  readonly delete_follows?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly followed_entity: any;
      readonly followed_id: string;
      readonly id: string;
      readonly user_id: string;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneFollowMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneFollowMutationQuery = {
  readonly delete_follows_by_pk?: {
    readonly created_at?: string | null;
    readonly followed_entity: any;
    readonly followed_id: string;
    readonly id: string;
    readonly user_id: string;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type DeleteManyMetricDefinitionMutationVariables = Exact<{
  where: MetricDefinitionsBoolExp;
}>;

export type DeleteManyMetricDefinitionMutationQuery = {
  readonly delete_metric_definitions?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category?: string | null;
      readonly description?: string | null;
      readonly id: number;
      readonly is_dimensional?: boolean | null;
      readonly name: string;
      readonly type: string;
      readonly unit?: string | null;
      readonly company_metrics: ReadonlyArray<{
        readonly company_id: string;
        readonly crawl_id: string;
        readonly id: number;
        readonly metric_id?: number | null;
        readonly timestamp: string;
        readonly value: Record<string, any>;
      }>;
      readonly spider_metrics: ReadonlyArray<{
        readonly crawl_id: string;
        readonly id: number;
        readonly metric_id?: number | null;
        readonly timestamp: string;
        readonly value: Record<string, any>;
      }>;
    }>;
  } | null;
};

export type DeleteOneMetricDefinitionMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneMetricDefinitionMutationQuery = {
  readonly delete_metric_definitions_by_pk?: {
    readonly category?: string | null;
    readonly description?: string | null;
    readonly id: number;
    readonly is_dimensional?: boolean | null;
    readonly name: string;
    readonly type: string;
    readonly unit?: string | null;
    readonly company_metrics: ReadonlyArray<{
      readonly company_id: string;
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
    }>;
    readonly spider_metrics: ReadonlyArray<{
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
    }>;
  } | null;
};

export type DeleteManyNewsMutationVariables = Exact<{
  where: NewsBoolExp;
}>;

export type DeleteManyNewsMutationQuery = {
  readonly delete_news?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
      readonly category?: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly content_source?: {
        readonly company_id?: string | null;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly expected_count?: any | null;
        readonly failed_count?: any | null;
        readonly has_failed?: boolean | null;
        readonly hash?: number | null;
        readonly id: number;
        readonly priority: any;
        readonly refreshed_at?: string | null;
        readonly rss_urls?: ReadonlyArray<string> | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly news_summaries: ReadonlyArray<{
        readonly complexity_level?: any | null;
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly id: string;
        readonly is_current?: boolean | null;
        readonly news_id: string;
        readonly summary?: string | null;
        readonly updated_at?: string | null;
        readonly version: number;
      }>;
    }>;
  } | null;
};

export type DeleteOneNewsMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneNewsMutationQuery = {
  readonly delete_news_by_pk?: {
    readonly author?: string | null;
    readonly body?: string | null;
    readonly category_id?: number | null;
    readonly company_id?: string | null;
    readonly content_source_id?: number | null;
    readonly content_status: any;
    readonly created_at: string;
    readonly description?: string | null;
    readonly failed_count?: any | null;
    readonly featured_image?: string | null;
    readonly has_summary: boolean;
    readonly hash?: number | null;
    readonly id: string;
    readonly keywords?: Record<string, any> | null;
    readonly published_at?: string | null;
    readonly scrape_frequency: any;
    readonly scraped_at?: string | null;
    readonly title?: string | null;
    readonly updated_at: string;
    readonly url: string;
    readonly category?: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly content_source?: {
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly news_summaries: ReadonlyArray<{
      readonly complexity_level?: any | null;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: string;
      readonly is_current?: boolean | null;
      readonly news_id: string;
      readonly summary?: string | null;
      readonly updated_at?: string | null;
      readonly version: number;
    }>;
  } | null;
};

export type DeleteManyNewsSummaryMutationVariables = Exact<{
  where: NewsSummariesBoolExp;
}>;

export type DeleteManyNewsSummaryMutationQuery = {
  readonly delete_news_summaries?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly complexity_level?: any | null;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: string;
      readonly is_current?: boolean | null;
      readonly news_id: string;
      readonly summary?: string | null;
      readonly updated_at?: string | null;
      readonly version: number;
      readonly news: {
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      };
    }>;
  } | null;
};

export type DeleteOneNewsSummaryMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneNewsSummaryMutationQuery = {
  readonly delete_news_summaries_by_pk?: {
    readonly complexity_level?: any | null;
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly id: string;
    readonly is_current?: boolean | null;
    readonly news_id: string;
    readonly summary?: string | null;
    readonly updated_at?: string | null;
    readonly version: number;
    readonly news: {
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    };
  } | null;
};

export type DeleteManyNewsTagMutationVariables = Exact<{
  where: NewsTagsBoolExp;
}>;

export type DeleteManyNewsTagMutationQuery = {
  readonly delete_news_tags?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly id: number;
      readonly news_id?: string | null;
      readonly tag_id: number;
      readonly tag: {
        readonly body?: string | null;
        readonly created_at?: string | null;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneNewsTagMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneNewsTagMutationQuery = {
  readonly delete_news_tags_by_pk?: {
    readonly id: number;
    readonly news_id?: string | null;
    readonly tag_id: number;
    readonly tag: {
      readonly body?: string | null;
      readonly created_at?: string | null;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    };
  } | null;
};

export type DeleteManyNewsletterMutationVariables = Exact<{
  where: NewslettersBoolExp;
}>;

export type DeleteManyNewsletterMutationQuery = {
  readonly delete_newsletters?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly frequency: string;
      readonly generated_content?: string | null;
      readonly id: string;
      readonly start_date: string;
      readonly title: string;
      readonly updated_at?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null;
};

export type DeleteOneNewsletterMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneNewsletterMutationQuery = {
  readonly delete_newsletters_by_pk?: {
    readonly content_status: any;
    readonly created_at?: string | null;
    readonly end_date: string;
    readonly frequency: string;
    readonly generated_content?: string | null;
    readonly id: string;
    readonly start_date: string;
    readonly title: string;
    readonly updated_at?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type DeleteManyPaymentProviderMutationVariables = Exact<{
  where: PaymentProvidersBoolExp;
}>;

export type DeleteManyPaymentProviderMutationQuery = {
  readonly delete_payment_providers?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_active?: boolean | null;
      readonly name: string;
      readonly updated_at?: string | null;
      readonly customer_payments: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      }>;
      readonly customer_subscriptions: ReadonlyArray<{
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
    }>;
  } | null;
};

export type DeleteOnePaymentProviderMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOnePaymentProviderMutationQuery = {
  readonly delete_payment_providers_by_pk?: {
    readonly created_at?: string | null;
    readonly id: number;
    readonly is_active?: boolean | null;
    readonly name: string;
    readonly updated_at?: string | null;
    readonly customer_payments: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
    readonly customer_subscriptions: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  } | null;
};

export type DeleteManyPlanPermissionMutationVariables = Exact<{
  where: PlanPermissionsBoolExp;
}>;

export type DeleteManyPlanPermissionMutationQuery = {
  readonly delete_plan_permissions?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly feature: string;
      readonly id: number;
      readonly plan: any;
    }>;
  } | null;
};

export type DeleteOnePlanPermissionMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOnePlanPermissionMutationQuery = {
  readonly delete_plan_permissions_by_pk?: {
    readonly feature: string;
    readonly id: number;
    readonly plan: any;
  } | null;
};

export type DeleteManyRecentErrorMutationVariables = Exact<{
  where: RecentErrorsBoolExp;
}>;

export type DeleteManyRecentErrorMutationQuery = {
  readonly delete_recent_errors?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly error_type?: any | null;
      readonly message?: string | null;
      readonly metadata?: Record<string, any> | null;
      readonly service_name?: string | null;
      readonly severity?: any | null;
    }>;
  } | null;
};

export type DeleteManyReferralMutationVariables = Exact<{
  where: ReferralsBoolExp;
}>;

export type DeleteManyReferralMutationQuery = {
  readonly delete_referrals?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly browser?: string | null;
      readonly client_fingerprint?: string | null;
      readonly conversion_value?: number | null;
      readonly converted_at?: string | null;
      readonly country_code?: string | null;
      readonly created_at?: string | null;
      readonly device_type?: string | null;
      readonly id: string;
      readonly ip_address?: any | null;
      readonly is_suspicious?: boolean | null;
      readonly landing_page?: string | null;
      readonly last_failed_attempt?: string | null;
      readonly referral_status?: any | null;
      readonly referrer_code: string;
      readonly region?: string | null;
      readonly security_flags?: Record<string, any> | null;
      readonly user_agent?: string | null;
      readonly utm_campaign?: string | null;
      readonly utm_medium?: string | null;
      readonly utm_source?: string | null;
      readonly validation_attempts?: number | null;
      readonly visitor_id: string;
    }>;
  } | null;
};

export type DeleteOneReferralMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneReferralMutationQuery = {
  readonly delete_referrals_by_pk?: {
    readonly browser?: string | null;
    readonly client_fingerprint?: string | null;
    readonly conversion_value?: number | null;
    readonly converted_at?: string | null;
    readonly country_code?: string | null;
    readonly created_at?: string | null;
    readonly device_type?: string | null;
    readonly id: string;
    readonly ip_address?: any | null;
    readonly is_suspicious?: boolean | null;
    readonly landing_page?: string | null;
    readonly last_failed_attempt?: string | null;
    readonly referral_status?: any | null;
    readonly referrer_code: string;
    readonly region?: string | null;
    readonly security_flags?: Record<string, any> | null;
    readonly user_agent?: string | null;
    readonly utm_campaign?: string | null;
    readonly utm_medium?: string | null;
    readonly utm_source?: string | null;
    readonly validation_attempts?: number | null;
    readonly visitor_id: string;
  } | null;
};

export type DeleteManyReferrerBlockMutationVariables = Exact<{
  where: ReferrerBlocksBoolExp;
}>;

export type DeleteManyReferrerBlockMutationQuery = {
  readonly delete_referrer_blocks?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly blocked_at?: string | null;
      readonly blocked_by: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_permanent?: boolean | null;
      readonly reason?: string | null;
      readonly referrer_code: string;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type DeleteOneReferrerBlockMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneReferrerBlockMutationQuery = {
  readonly delete_referrer_blocks_by_pk?: {
    readonly blocked_at?: string | null;
    readonly blocked_by: string;
    readonly created_at?: string | null;
    readonly id: string;
    readonly is_permanent?: boolean | null;
    readonly reason?: string | null;
    readonly referrer_code: string;
    readonly updated_at?: string | null;
  } | null;
};

export type DeleteManyResearchMutationVariables = Exact<{
  where: ResearchBoolExp;
}>;

export type DeleteManyResearchMutationQuery = {
  readonly delete_research?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly research_embedding?: {
        readonly chunk: string;
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly embedding_review_id?: number | null;
        readonly id: number;
        readonly is_flagged?: boolean | null;
        readonly research_id: string;
        readonly updated_at: string;
        readonly url?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneResearchMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneResearchMutationQuery = {
  readonly delete_research_by_pk?: {
    readonly abstract?: string | null;
    readonly abstract_url: string;
    readonly affiliations?: Record<string, any> | null;
    readonly authors?: Record<string, any> | null;
    readonly category?: string | null;
    readonly comments?: string | null;
    readonly content_status: any;
    readonly created_at: string;
    readonly doi_url?: string | null;
    readonly figure_count?: any | null;
    readonly has_embedding?: boolean | null;
    readonly id: string;
    readonly is_flagged: boolean;
    readonly keywords?: string | null;
    readonly month?: string | null;
    readonly page_count?: any | null;
    readonly pdf_url?: string | null;
    readonly published_at?: string | null;
    readonly published_in?: string | null;
    readonly summary?: string | null;
    readonly table_count?: any | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly version?: any | null;
    readonly year?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly research_embedding?: {
      readonly chunk: string;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly embedding_review_id?: number | null;
      readonly id: number;
      readonly is_flagged?: boolean | null;
      readonly research_id: string;
      readonly updated_at: string;
      readonly url?: string | null;
    } | null;
  } | null;
};

export type DeleteManyResearchEmbeddingMutationVariables = Exact<{
  where: ResearchEmbeddingsBoolExp;
}>;

export type DeleteManyResearchEmbeddingMutationQuery = {
  readonly delete_research_embeddings?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly chunk: string;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly embedding_review_id?: number | null;
      readonly id: number;
      readonly is_flagged?: boolean | null;
      readonly research_id: string;
      readonly updated_at: string;
      readonly url?: string | null;
      readonly embedding_review?: {
        readonly agent_review?: boolean | null;
        readonly created_at: string;
        readonly human_review?: boolean | null;
        readonly id: number;
        readonly notes?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly research: {
        readonly abstract?: string | null;
        readonly abstract_url: string;
        readonly affiliations?: Record<string, any> | null;
        readonly authors?: Record<string, any> | null;
        readonly category?: string | null;
        readonly comments?: string | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly doi_url?: string | null;
        readonly figure_count?: any | null;
        readonly has_embedding?: boolean | null;
        readonly id: string;
        readonly is_flagged: boolean;
        readonly keywords?: string | null;
        readonly month?: string | null;
        readonly page_count?: any | null;
        readonly pdf_url?: string | null;
        readonly published_at?: string | null;
        readonly published_in?: string | null;
        readonly summary?: string | null;
        readonly table_count?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly version?: any | null;
        readonly year?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneResearchEmbeddingMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneResearchEmbeddingMutationQuery = {
  readonly delete_research_embeddings_by_pk?: {
    readonly chunk: string;
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly embedding_review_id?: number | null;
    readonly id: number;
    readonly is_flagged?: boolean | null;
    readonly research_id: string;
    readonly updated_at: string;
    readonly url?: string | null;
    readonly embedding_review?: {
      readonly agent_review?: boolean | null;
      readonly created_at: string;
      readonly human_review?: boolean | null;
      readonly id: number;
      readonly notes?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly research: {
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
    };
  } | null;
};

export type DeleteManyResponseMutationVariables = Exact<{
  where: ResponsesBoolExp;
}>;

export type DeleteManyResponseMutationQuery = {
  readonly delete_responses?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly downvotes?: number | null;
      readonly id: number;
      readonly output: string;
      readonly search_id: number;
      readonly upvotes?: number | null;
      readonly search: {
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly id: number;
        readonly input: string;
        readonly tokens_used?: any | null;
        readonly user_ids?: ReadonlyArray<string> | null;
      };
    }>;
  } | null;
};

export type DeleteOneResponseMutationVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneResponseMutationQuery = {
  readonly delete_responses_by_pk?: {
    readonly created_at?: string | null;
    readonly downvotes?: number | null;
    readonly id: number;
    readonly output: string;
    readonly search_id: number;
    readonly upvotes?: number | null;
    readonly search: {
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: number;
      readonly input: string;
      readonly tokens_used?: any | null;
      readonly user_ids?: ReadonlyArray<string> | null;
    };
  } | null;
};

export type DeleteManyRoleHierarchyMutationVariables = Exact<{
  where: RoleHierarchyBoolExp;
}>;

export type DeleteManyRoleHierarchyMutationQuery = {
  readonly delete_role_hierarchy?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly child_role: any;
      readonly parent_role: any;
    }>;
  } | null;
};

export type DeleteOneRoleHierarchyMutationVariables = Exact<{
  child_role: Scalars["app_role_enum"]["input"];
  parent_role: Scalars["app_role_enum"]["input"];
}>;

export type DeleteOneRoleHierarchyMutationQuery = {
  readonly delete_role_hierarchy_by_pk?: {
    readonly child_role: any;
    readonly parent_role: any;
  } | null;
};

export type DeleteManyRolePermissionMutationVariables = Exact<{
  where: RolePermissionsBoolExp;
}>;

export type DeleteManyRolePermissionMutationQuery = {
  readonly delete_role_permissions?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly cached_permissions?: Record<string, any> | null;
      readonly conditions?: Record<string, any> | null;
      readonly id: number;
      readonly inherit_from?: ReadonlyArray<any> | null;
      readonly last_updated?: string | null;
      readonly permissions?: Record<string, any> | null;
      readonly role: any;
      readonly table_name: string;
    }>;
  } | null;
};

export type DeleteOneRolePermissionMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneRolePermissionMutationQuery = {
  readonly delete_role_permissions_by_pk?: {
    readonly cached_permissions?: Record<string, any> | null;
    readonly conditions?: Record<string, any> | null;
    readonly id: number;
    readonly inherit_from?: ReadonlyArray<any> | null;
    readonly last_updated?: string | null;
    readonly permissions?: Record<string, any> | null;
    readonly role: any;
    readonly table_name: string;
  } | null;
};

export type DeleteManyRolePermissionsMaterializedMutationVariables = Exact<{
  where: RolePermissionsMaterializedBoolExp;
}>;

export type DeleteManyRolePermissionsMaterializedMutationQuery = {
  readonly delete_role_permissions_materialized?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly last_updated?: string | null;
      readonly permissions: Record<string, any>;
      readonly role: any;
    }>;
  } | null;
};

export type DeleteOneRolePermissionsMaterializedMutationVariables = Exact<{
  role: Scalars["app_role_enum"]["input"];
}>;

export type DeleteOneRolePermissionsMaterializedMutationQuery = {
  readonly delete_role_permissions_materialized_by_pk?: {
    readonly last_updated?: string | null;
    readonly permissions: Record<string, any>;
    readonly role: any;
  } | null;
};

export type DeleteManyScoringWeightMutationVariables = Exact<{
  where: ScoringWeightsBoolExp;
}>;

export type DeleteManyScoringWeightMutationQuery = {
  readonly delete_scoring_weights?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly description?: string | null;
      readonly id: string;
      readonly name: string;
      readonly updated_at?: string | null;
      readonly weight: any;
    }>;
  } | null;
};

export type DeleteOneScoringWeightMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneScoringWeightMutationQuery = {
  readonly delete_scoring_weights_by_pk?: {
    readonly description?: string | null;
    readonly id: string;
    readonly name: string;
    readonly updated_at?: string | null;
    readonly weight: any;
  } | null;
};

export type DeleteManySearchMutationVariables = Exact<{
  where: SearchesBoolExp;
}>;

export type DeleteManySearchMutationQuery = {
  readonly delete_searches?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: number;
      readonly input: string;
      readonly tokens_used?: any | null;
      readonly user_ids?: ReadonlyArray<string> | null;
      readonly responses: ReadonlyArray<{
        readonly created_at?: string | null;
        readonly downvotes?: number | null;
        readonly id: number;
        readonly output: string;
        readonly search_id: number;
        readonly upvotes?: number | null;
      }>;
    }>;
  } | null;
};

export type DeleteOneSearchMutationVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneSearchMutationQuery = {
  readonly delete_searches_by_pk?: {
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly id: number;
    readonly input: string;
    readonly tokens_used?: any | null;
    readonly user_ids?: ReadonlyArray<string> | null;
    readonly responses: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly downvotes?: number | null;
      readonly id: number;
      readonly output: string;
      readonly search_id: number;
      readonly upvotes?: number | null;
    }>;
  } | null;
};

export type DeleteManySocialMediaMutationVariables = Exact<{
  where: SocialMediaBoolExp;
}>;

export type DeleteManySocialMediaMutationQuery = {
  readonly delete_social_media?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly facebook_url?: string | null;
      readonly id: number;
      readonly instagram_url?: string | null;
      readonly linkedin_url?: string | null;
      readonly twitter_url?: string | null;
      readonly updated_at?: string | null;
      readonly youtube_url?: string | null;
      readonly companies: ReadonlyArray<{
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
    }>;
  } | null;
};

export type DeleteOneSocialMediaMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneSocialMediaMutationQuery = {
  readonly delete_social_media_by_pk?: {
    readonly created_at?: string | null;
    readonly facebook_url?: string | null;
    readonly id: number;
    readonly instagram_url?: string | null;
    readonly linkedin_url?: string | null;
    readonly twitter_url?: string | null;
    readonly updated_at?: string | null;
    readonly youtube_url?: string | null;
    readonly companies: ReadonlyArray<{
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
  } | null;
};

export type DeleteManySpiderMetricMutationVariables = Exact<{
  where: SpiderMetricsBoolExp;
}>;

export type DeleteManySpiderMetricMutationQuery = {
  readonly delete_spider_metrics?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
      readonly metric_definition?: {
        readonly category?: string | null;
        readonly description?: string | null;
        readonly id: number;
        readonly is_dimensional?: boolean | null;
        readonly name: string;
        readonly type: string;
        readonly unit?: string | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneSpiderMetricMutationVariables = Exact<{
  id: Scalars["bigint"]["input"];
}>;

export type DeleteOneSpiderMetricMutationQuery = {
  readonly delete_spider_metrics_by_pk?: {
    readonly crawl_id: string;
    readonly id: number;
    readonly metric_id?: number | null;
    readonly timestamp: string;
    readonly value: Record<string, any>;
    readonly metric_definition?: {
      readonly category?: string | null;
      readonly description?: string | null;
      readonly id: number;
      readonly is_dimensional?: boolean | null;
      readonly name: string;
      readonly type: string;
      readonly unit?: string | null;
    } | null;
  } | null;
};

export type DeleteManyStrapiMigrationMutationVariables = Exact<{
  where: StrapiMigrationsBoolExp;
}>;

export type DeleteManyStrapiMigrationMutationQuery = {
  readonly delete_strapi_migrations?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly id: number;
      readonly name?: string | null;
      readonly time?: string | null;
    }>;
  } | null;
};

export type DeleteOneStrapiMigrationMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneStrapiMigrationMutationQuery = {
  readonly delete_strapi_migrations_by_pk?: {
    readonly id: number;
    readonly name?: string | null;
    readonly time?: string | null;
  } | null;
};

export type DeleteManyStrapiMigrationsInternalMutationVariables = Exact<{
  where: StrapiMigrationsInternalBoolExp;
}>;

export type DeleteManyStrapiMigrationsInternalMutationQuery = {
  readonly delete_strapi_migrations_internal?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly id: number;
      readonly name?: string | null;
      readonly time?: string | null;
    }>;
  } | null;
};

export type DeleteOneStrapiMigrationsInternalMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneStrapiMigrationsInternalMutationQuery = {
  readonly delete_strapi_migrations_internal_by_pk?: {
    readonly id: number;
    readonly name?: string | null;
    readonly time?: string | null;
  } | null;
};

export type DeleteManyTableMaintenanceLogMutationVariables = Exact<{
  where: TableMaintenanceLogBoolExp;
}>;

export type DeleteManyTableMaintenanceLogMutationQuery = {
  readonly delete_table_maintenance_log?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly detail?: string | null;
      readonly id: number;
      readonly logged_at?: string | null;
      readonly operation?: string | null;
    }>;
  } | null;
};

export type DeleteOneTableMaintenanceLogMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneTableMaintenanceLogMutationQuery = {
  readonly delete_table_maintenance_log_by_pk?: {
    readonly detail?: string | null;
    readonly id: number;
    readonly logged_at?: string | null;
    readonly operation?: string | null;
  } | null;
};

export type DeleteManyTableQueryPerformanceMutationVariables = Exact<{
  where: TableQueryPerformanceBoolExp;
}>;

export type DeleteManyTableQueryPerformanceMutationQuery = {
  readonly delete_table_query_performance?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly avg_duration?: any | null;
      readonly capture_time?: string | null;
      readonly execution_count?: number | null;
      readonly query?: string | null;
    }>;
  } | null;
};

export type DeleteManyTableSequenceUsageMutationVariables = Exact<{
  where: TableSequenceUsageBoolExp;
}>;

export type DeleteManyTableSequenceUsageMutationQuery = {
  readonly delete_table_sequence_usage?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly capture_time?: string | null;
      readonly current_value?: number | null;
      readonly max_value?: number | null;
      readonly sequence_name?: string | null;
    }>;
  } | null;
};

export type DeleteManyTableStatisticMutationVariables = Exact<{
  where: TableStatisticsBoolExp;
}>;

export type DeleteManyTableStatisticMutationQuery = {
  readonly delete_table_statistics?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly buffer_cache_hit_ratio?: any | null;
      readonly capture_time: string;
      readonly dead_tuples?: number | null;
      readonly estimated_bloat_ratio?: any | null;
      readonly index_scan_count?: number | null;
      readonly index_size?: number | null;
      readonly index_usage?: Record<string, any> | null;
      readonly last_analyze?: string | null;
      readonly last_vacuum?: string | null;
      readonly live_tuples?: number | null;
      readonly row_count?: number | null;
      readonly seq_scan_count?: number | null;
      readonly table_name: string;
      readonly table_size?: number | null;
    }>;
  } | null;
};

export type DeleteOneTableStatisticMutationVariables = Exact<{
  capture_time: Scalars["timestamptz"]["input"];
  table_name: Scalars["String"]["input"];
}>;

export type DeleteOneTableStatisticMutationQuery = {
  readonly delete_table_statistics_by_pk?: {
    readonly buffer_cache_hit_ratio?: any | null;
    readonly capture_time: string;
    readonly dead_tuples?: number | null;
    readonly estimated_bloat_ratio?: any | null;
    readonly index_scan_count?: number | null;
    readonly index_size?: number | null;
    readonly index_usage?: Record<string, any> | null;
    readonly last_analyze?: string | null;
    readonly last_vacuum?: string | null;
    readonly live_tuples?: number | null;
    readonly row_count?: number | null;
    readonly seq_scan_count?: number | null;
    readonly table_name: string;
    readonly table_size?: number | null;
  } | null;
};

export type DeleteManyTagMutationVariables = Exact<{
  where: TagsBoolExp;
}>;

export type DeleteManyTagMutationQuery = {
  readonly delete_tags?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly body?: string | null;
      readonly created_at?: string | null;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
      readonly content_tags: ReadonlyArray<{
        readonly content_id: string;
        readonly tag_id: number;
      }>;
      readonly news_tags: ReadonlyArray<{
        readonly id: number;
        readonly news_id?: string | null;
        readonly tag_id: number;
      }>;
    }>;
  } | null;
};

export type DeleteOneTagMutationVariables = Exact<{
  id: Scalars["Int"]["input"];
}>;

export type DeleteOneTagMutationQuery = {
  readonly delete_tags_by_pk?: {
    readonly body?: string | null;
    readonly created_at?: string | null;
    readonly document_id?: string | null;
    readonly id: number;
    readonly locale?: string | null;
    readonly name: string;
    readonly published_at?: string | null;
    readonly updated_at?: string | null;
    readonly content_tags: ReadonlyArray<{
      readonly content_id: string;
      readonly tag_id: number;
    }>;
    readonly news_tags: ReadonlyArray<{
      readonly id: number;
      readonly news_id?: string | null;
      readonly tag_id: number;
    }>;
  } | null;
};

export type DeleteManyUserMetricMutationVariables = Exact<{
  where: UserMetricsBoolExp;
}>;

export type DeleteManyUserMetricMutationQuery = {
  readonly delete_user_metrics?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly achievements?: Record<string, any> | null;
      readonly best_streak?: number | null;
      readonly created_at?: string | null;
      readonly current_level?: number | null;
      readonly current_streak?: number | null;
      readonly current_xp?: number | null;
      readonly downvote_count?: number | null;
      readonly id: string;
      readonly interaction_stats?: Record<string, any> | null;
      readonly last_vote_date?: string | null;
      readonly multipliers?: Record<string, any> | null;
      readonly points?: number | null;
      readonly points_breakdown?: Record<string, any> | null;
      readonly titles?: Record<string, any> | null;
      readonly today_vote_count?: number | null;
      readonly total_reading_time?: number | null;
      readonly total_votes?: number | null;
      readonly updated_at?: string | null;
      readonly upvote_count?: number | null;
      readonly user_id: string;
      readonly vote_accuracy?: number | null;
      readonly xp_to_next_level?: number | null;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type DeleteOneUserMetricMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneUserMetricMutationQuery = {
  readonly delete_user_metrics_by_pk?: {
    readonly achievements?: Record<string, any> | null;
    readonly best_streak?: number | null;
    readonly created_at?: string | null;
    readonly current_level?: number | null;
    readonly current_streak?: number | null;
    readonly current_xp?: number | null;
    readonly downvote_count?: number | null;
    readonly id: string;
    readonly interaction_stats?: Record<string, any> | null;
    readonly last_vote_date?: string | null;
    readonly multipliers?: Record<string, any> | null;
    readonly points?: number | null;
    readonly points_breakdown?: Record<string, any> | null;
    readonly titles?: Record<string, any> | null;
    readonly today_vote_count?: number | null;
    readonly total_reading_time?: number | null;
    readonly total_votes?: number | null;
    readonly updated_at?: string | null;
    readonly upvote_count?: number | null;
    readonly user_id: string;
    readonly vote_accuracy?: number | null;
    readonly xp_to_next_level?: number | null;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type DeleteManyUserProfileMutationVariables = Exact<{
  where: UserProfilesBoolExp;
}>;

export type DeleteManyUserProfileMutationQuery = {
  readonly delete_user_profiles?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly comments: ReadonlyArray<{
        readonly content: string;
        readonly content_id: string;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly id: string;
        readonly parent_comment_id?: string | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly company_employees: ReadonlyArray<{
        readonly access_level: any;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date?: string | null;
        readonly id: string;
        readonly job_description?: string | null;
        readonly role: string;
        readonly start_date?: string | null;
        readonly status?: boolean | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_type?: any | null;
        readonly created_at?: string | null;
        readonly email?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly phone?: string | null;
        readonly privacy_level?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly content_source_visits: ReadonlyArray<{
        readonly content_id: string;
        readonly created_at?: string | null;
        readonly id: string;
        readonly user_id?: string | null;
      }>;
      readonly customer_payments: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      }>;
      readonly customer_subscriptions: ReadonlyArray<{
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly feedbacks: ReadonlyArray<{
        readonly created_at: string;
        readonly device_info?: string | null;
        readonly feedback_status?: any | null;
        readonly feedback_type?: any | null;
        readonly id: number;
        readonly message: string;
        readonly page_identifier: string;
        readonly rating?: number | null;
        readonly resolution_comment?: string | null;
        readonly updated_at: string;
        readonly user_id?: string | null;
      }>;
      readonly feeds: ReadonlyArray<{
        readonly created_at: string;
        readonly id: string;
        readonly name?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly follows: ReadonlyArray<{
        readonly created_at?: string | null;
        readonly followed_entity: any;
        readonly followed_id: string;
        readonly id: string;
        readonly user_id: string;
      }>;
      readonly user_metric?: {
        readonly achievements?: Record<string, any> | null;
        readonly best_streak?: number | null;
        readonly created_at?: string | null;
        readonly current_level?: number | null;
        readonly current_streak?: number | null;
        readonly current_xp?: number | null;
        readonly downvote_count?: number | null;
        readonly id: string;
        readonly interaction_stats?: Record<string, any> | null;
        readonly last_vote_date?: string | null;
        readonly multipliers?: Record<string, any> | null;
        readonly points?: number | null;
        readonly points_breakdown?: Record<string, any> | null;
        readonly titles?: Record<string, any> | null;
        readonly today_vote_count?: number | null;
        readonly total_reading_time?: number | null;
        readonly total_votes?: number | null;
        readonly updated_at?: string | null;
        readonly upvote_count?: number | null;
        readonly user_id: string;
        readonly vote_accuracy?: number | null;
        readonly xp_to_next_level?: number | null;
      } | null;
    }>;
  } | null;
};

export type DeleteOneUserProfileMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneUserProfileMutationQuery = {
  readonly delete_user_profiles_by_pk?: {
    readonly avatar?: string | null;
    readonly created_at?: string | null;
    readonly dob?: any | null;
    readonly email: string;
    readonly followed_count?: number | null;
    readonly followers_count?: number | null;
    readonly gender_id?: any | null;
    readonly given_name?: string | null;
    readonly id: string;
    readonly introduction?: string | null;
    readonly is_active?: boolean | null;
    readonly last_seen?: string | null;
    readonly plan?: any | null;
    readonly role: any;
    readonly surname?: string | null;
    readonly updated_at?: string | null;
    readonly username?: string | null;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly comments: ReadonlyArray<{
      readonly content: string;
      readonly content_id: string;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly parent_comment_id?: string | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly company_employees: ReadonlyArray<{
      readonly access_level: any;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date?: string | null;
      readonly id: string;
      readonly job_description?: string | null;
      readonly role: string;
      readonly start_date?: string | null;
      readonly status?: boolean | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly content_source_visits: ReadonlyArray<{
      readonly content_id: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id?: string | null;
    }>;
    readonly customer_payments: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
    readonly customer_subscriptions: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly feedbacks: ReadonlyArray<{
      readonly created_at: string;
      readonly device_info?: string | null;
      readonly feedback_status?: any | null;
      readonly feedback_type?: any | null;
      readonly id: number;
      readonly message: string;
      readonly page_identifier: string;
      readonly rating?: number | null;
      readonly resolution_comment?: string | null;
      readonly updated_at: string;
      readonly user_id?: string | null;
    }>;
    readonly feeds: ReadonlyArray<{
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly follows: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly followed_entity: any;
      readonly followed_id: string;
      readonly id: string;
      readonly user_id: string;
    }>;
    readonly user_metric?: {
      readonly achievements?: Record<string, any> | null;
      readonly best_streak?: number | null;
      readonly created_at?: string | null;
      readonly current_level?: number | null;
      readonly current_streak?: number | null;
      readonly current_xp?: number | null;
      readonly downvote_count?: number | null;
      readonly id: string;
      readonly interaction_stats?: Record<string, any> | null;
      readonly last_vote_date?: string | null;
      readonly multipliers?: Record<string, any> | null;
      readonly points?: number | null;
      readonly points_breakdown?: Record<string, any> | null;
      readonly titles?: Record<string, any> | null;
      readonly today_vote_count?: number | null;
      readonly total_reading_time?: number | null;
      readonly total_votes?: number | null;
      readonly updated_at?: string | null;
      readonly upvote_count?: number | null;
      readonly user_id: string;
      readonly vote_accuracy?: number | null;
      readonly xp_to_next_level?: number | null;
    } | null;
  } | null;
};

export type DeleteManyVoteMutationVariables = Exact<{
  where: VotesBoolExp;
}>;

export type DeleteManyVoteMutationQuery = {
  readonly delete_votes?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id: string;
      readonly vote_type: any;
    }>;
  } | null;
};

export type DeleteOneVoteMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneVoteMutationQuery = {
  readonly delete_votes_by_pk?: {
    readonly content_id: string;
    readonly content_type: string;
    readonly created_at?: string | null;
    readonly id: string;
    readonly user_id: string;
    readonly vote_type: any;
  } | null;
};

export type DeleteManyWorkflowMutationVariables = Exact<{
  where: WorkflowsBoolExp;
}>;

export type DeleteManyWorkflowMutationQuery = {
  readonly delete_workflows?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly completed_at?: string | null;
      readonly created_at?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly name: string;
      readonly started_at?: string | null;
      readonly status: any;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type DeleteOneWorkflowMutationVariables = Exact<{
  id: Scalars["uuid"]["input"];
}>;

export type DeleteOneWorkflowMutationQuery = {
  readonly delete_workflows_by_pk?: {
    readonly completed_at?: string | null;
    readonly created_at?: string | null;
    readonly id: string;
    readonly metadata?: Record<string, any> | null;
    readonly name: string;
    readonly started_at?: string | null;
    readonly status: any;
    readonly updated_at?: string | null;
  } | null;
};

export type CreateManyAdDailyMetricMutationVariables = Exact<{
  objects: ReadonlyArray<AdDailyMetricsInsertInput> | AdDailyMetricsInsertInput;
  on_conflict?: InputMaybe<AdDailyMetricsOnConflict>;
}>;

export type CreateManyAdDailyMetricMutationQuery = {
  readonly insert_ad_daily_metrics?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly clicks?: number | null;
      readonly created_at?: string | null;
      readonly date: any;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly variant_id?: string | null;
      readonly views?: number | null;
      readonly ad_variant?: {
        readonly active?: boolean | null;
        readonly ad_id: string;
        readonly content: Record<string, any>;
        readonly created_at?: string | null;
        readonly id: string;
        readonly is_control?: boolean | null;
        readonly performance_metrics?: Record<string, any> | null;
        readonly updated_at?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneAdDailyMetricMutationVariables = Exact<{
  object: AdDailyMetricsInsertInput;
  on_conflict?: InputMaybe<AdDailyMetricsOnConflict>;
}>;

export type CreateOneAdDailyMetricMutationQuery = {
  readonly insert_ad_daily_metrics_one?: {
    readonly clicks?: number | null;
    readonly created_at?: string | null;
    readonly date: any;
    readonly id: string;
    readonly updated_at?: string | null;
    readonly variant_id?: string | null;
    readonly views?: number | null;
    readonly ad_variant?: {
      readonly active?: boolean | null;
      readonly ad_id: string;
      readonly content: Record<string, any>;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_control?: boolean | null;
      readonly performance_metrics?: Record<string, any> | null;
      readonly updated_at?: string | null;
    } | null;
  } | null;
};

export type CreateManyAdPackageMutationVariables = Exact<{
  objects: ReadonlyArray<AdPackagesInsertInput> | AdPackagesInsertInput;
  on_conflict?: InputMaybe<AdPackagesOnConflict>;
}>;

export type CreateManyAdPackageMutationQuery = {
  readonly insert_ad_packages?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly avg_roi?: number | null;
      readonly created_at?: string | null;
      readonly description: string;
      readonly expected_ctr?: number | null;
      readonly features: ReadonlyArray<string>;
      readonly id: string;
      readonly name: string;
      readonly position: string;
      readonly price: number;
      readonly updated_at?: string | null;
      readonly view_frequency?: number | null;
      readonly ads: ReadonlyArray<{
        readonly active?: boolean | null;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly id: string;
        readonly package_id?: string | null;
        readonly start_date: string;
        readonly updated_at?: string | null;
      }>;
    }>;
  } | null;
};

export type CreateOneAdPackageMutationVariables = Exact<{
  object: AdPackagesInsertInput;
  on_conflict?: InputMaybe<AdPackagesOnConflict>;
}>;

export type CreateOneAdPackageMutationQuery = {
  readonly insert_ad_packages_one?: {
    readonly active?: boolean | null;
    readonly avg_roi?: number | null;
    readonly created_at?: string | null;
    readonly description: string;
    readonly expected_ctr?: number | null;
    readonly features: ReadonlyArray<string>;
    readonly id: string;
    readonly name: string;
    readonly position: string;
    readonly price: number;
    readonly updated_at?: string | null;
    readonly view_frequency?: number | null;
    readonly ads: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type CreateManyAdVariantMutationVariables = Exact<{
  objects: ReadonlyArray<AdVariantsInsertInput> | AdVariantsInsertInput;
  on_conflict?: InputMaybe<AdVariantsOnConflict>;
}>;

export type CreateManyAdVariantMutationQuery = {
  readonly insert_ad_variants?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly ad_id: string;
      readonly content: Record<string, any>;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_control?: boolean | null;
      readonly performance_metrics?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly ad: {
        readonly active?: boolean | null;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly id: string;
        readonly package_id?: string | null;
        readonly start_date: string;
        readonly updated_at?: string | null;
      };
      readonly ad_daily_metrics: ReadonlyArray<{
        readonly clicks?: number | null;
        readonly created_at?: string | null;
        readonly date: any;
        readonly id: string;
        readonly updated_at?: string | null;
        readonly variant_id?: string | null;
        readonly views?: number | null;
      }>;
    }>;
  } | null;
};

export type CreateOneAdVariantMutationVariables = Exact<{
  object: AdVariantsInsertInput;
  on_conflict?: InputMaybe<AdVariantsOnConflict>;
}>;

export type CreateOneAdVariantMutationQuery = {
  readonly insert_ad_variants_one?: {
    readonly active?: boolean | null;
    readonly ad_id: string;
    readonly content: Record<string, any>;
    readonly created_at?: string | null;
    readonly id: string;
    readonly is_control?: boolean | null;
    readonly performance_metrics?: Record<string, any> | null;
    readonly updated_at?: string | null;
    readonly ad: {
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    };
    readonly ad_daily_metrics: ReadonlyArray<{
      readonly clicks?: number | null;
      readonly created_at?: string | null;
      readonly date: any;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly variant_id?: string | null;
      readonly views?: number | null;
    }>;
  } | null;
};

export type CreateManyAddressMutationVariables = Exact<{
  objects: ReadonlyArray<AddressesInsertInput> | AddressesInsertInput;
  on_conflict?: InputMaybe<AddressesOnConflict>;
}>;

export type CreateManyAddressMutationQuery = {
  readonly insert_addresses?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
      readonly city: {
        readonly country_id: number;
        readonly id: number;
        readonly name: string;
        readonly state?: string | null;
      };
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly country: {
        readonly code: string;
        readonly code_3?: string | null;
        readonly id: number;
        readonly name: string;
      };
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneAddressMutationVariables = Exact<{
  object: AddressesInsertInput;
  on_conflict?: InputMaybe<AddressesOnConflict>;
}>;

export type CreateOneAddressMutationQuery = {
  readonly insert_addresses_one?: {
    readonly address_type?: any | null;
    readonly city_id: number;
    readonly company_id?: string | null;
    readonly country_id: number;
    readonly created_at?: string | null;
    readonly id: number;
    readonly is_primary?: boolean | null;
    readonly name?: string | null;
    readonly street1: string;
    readonly street2?: string | null;
    readonly updated_at?: string | null;
    readonly user_id?: string | null;
    readonly city: {
      readonly country_id: number;
      readonly id: number;
      readonly name: string;
      readonly state?: string | null;
    };
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly country: {
      readonly code: string;
      readonly code_3?: string | null;
      readonly id: number;
      readonly name: string;
    };
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type CreateManyAdMutationVariables = Exact<{
  objects: ReadonlyArray<AdsInsertInput> | AdsInsertInput;
  on_conflict?: InputMaybe<AdsOnConflict>;
}>;

export type CreateManyAdMutationQuery = {
  readonly insert_ads?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
      readonly ad_package?: {
        readonly active?: boolean | null;
        readonly avg_roi?: number | null;
        readonly created_at?: string | null;
        readonly description: string;
        readonly expected_ctr?: number | null;
        readonly features: ReadonlyArray<string>;
        readonly id: string;
        readonly name: string;
        readonly position: string;
        readonly price: number;
        readonly updated_at?: string | null;
        readonly view_frequency?: number | null;
      } | null;
      readonly ad_variants: ReadonlyArray<{
        readonly active?: boolean | null;
        readonly ad_id: string;
        readonly content: Record<string, any>;
        readonly created_at?: string | null;
        readonly id: string;
        readonly is_control?: boolean | null;
        readonly performance_metrics?: Record<string, any> | null;
        readonly updated_at?: string | null;
      }>;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null;
};

export type CreateOneAdMutationVariables = Exact<{
  object: AdsInsertInput;
  on_conflict?: InputMaybe<AdsOnConflict>;
}>;

export type CreateOneAdMutationQuery = {
  readonly insert_ads_one?: {
    readonly active?: boolean | null;
    readonly company_id?: string | null;
    readonly created_at?: string | null;
    readonly end_date: string;
    readonly id: string;
    readonly package_id?: string | null;
    readonly start_date: string;
    readonly updated_at?: string | null;
    readonly ad_package?: {
      readonly active?: boolean | null;
      readonly avg_roi?: number | null;
      readonly created_at?: string | null;
      readonly description: string;
      readonly expected_ctr?: number | null;
      readonly features: ReadonlyArray<string>;
      readonly id: string;
      readonly name: string;
      readonly position: string;
      readonly price: number;
      readonly updated_at?: string | null;
      readonly view_frequency?: number | null;
    } | null;
    readonly ad_variants: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly ad_id: string;
      readonly content: Record<string, any>;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_control?: boolean | null;
      readonly performance_metrics?: Record<string, any> | null;
      readonly updated_at?: string | null;
    }>;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type CreateManyBlacklistedDomainMutationVariables = Exact<{
  objects:
    | ReadonlyArray<BlacklistedDomainsInsertInput>
    | BlacklistedDomainsInsertInput;
  on_conflict?: InputMaybe<BlacklistedDomainsOnConflict>;
}>;

export type CreateManyBlacklistedDomainMutationQuery = {
  readonly insert_blacklisted_domains?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at: string;
      readonly id: string;
      readonly reason?: string | null;
      readonly url: string;
    }>;
  } | null;
};

export type CreateOneBlacklistedDomainMutationVariables = Exact<{
  object: BlacklistedDomainsInsertInput;
  on_conflict?: InputMaybe<BlacklistedDomainsOnConflict>;
}>;

export type CreateOneBlacklistedDomainMutationQuery = {
  readonly insert_blacklisted_domains_one?: {
    readonly created_at: string;
    readonly id: string;
    readonly reason?: string | null;
    readonly url: string;
  } | null;
};

export type CreateManyBlacklistedUrlMutationVariables = Exact<{
  objects:
    | ReadonlyArray<BlacklistedUrlsInsertInput>
    | BlacklistedUrlsInsertInput;
  on_conflict?: InputMaybe<BlacklistedUrlsOnConflict>;
}>;

export type CreateManyBlacklistedUrlMutationQuery = {
  readonly insert_blacklisted_urls?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly id: number;
      readonly reason?: string | null;
      readonly url: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null;
};

export type CreateOneBlacklistedUrlMutationVariables = Exact<{
  object: BlacklistedUrlsInsertInput;
  on_conflict?: InputMaybe<BlacklistedUrlsOnConflict>;
}>;

export type CreateOneBlacklistedUrlMutationQuery = {
  readonly insert_blacklisted_urls_one?: {
    readonly company_id?: string | null;
    readonly created_at?: string | null;
    readonly id: number;
    readonly reason?: string | null;
    readonly url: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type CreateManyBlockedIpMutationVariables = Exact<{
  objects: ReadonlyArray<BlockedIpsInsertInput> | BlockedIpsInsertInput;
  on_conflict?: InputMaybe<BlockedIpsOnConflict>;
}>;

export type CreateManyBlockedIpMutationQuery = {
  readonly insert_blocked_ips?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly blocked_at?: string | null;
      readonly blocked_until: string;
      readonly created_at?: string | null;
      readonly failed_attempts?: number | null;
      readonly id: string;
      readonly ip_address: any;
      readonly reason?: string | null;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type CreateOneBlockedIpMutationVariables = Exact<{
  object: BlockedIpsInsertInput;
  on_conflict?: InputMaybe<BlockedIpsOnConflict>;
}>;

export type CreateOneBlockedIpMutationQuery = {
  readonly insert_blocked_ips_one?: {
    readonly blocked_at?: string | null;
    readonly blocked_until: string;
    readonly created_at?: string | null;
    readonly failed_attempts?: number | null;
    readonly id: string;
    readonly ip_address: any;
    readonly reason?: string | null;
    readonly updated_at?: string | null;
  } | null;
};

export type CreateManyBookmarkFolderMutationVariables = Exact<{
  objects:
    | ReadonlyArray<BookmarkFoldersInsertInput>
    | BookmarkFoldersInsertInput;
  on_conflict?: InputMaybe<BookmarkFoldersOnConflict>;
}>;

export type CreateManyBookmarkFolderMutationQuery = {
  readonly insert_bookmark_folders?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly color?: string | null;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_default?: boolean | null;
      readonly is_favorite?: boolean | null;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly path?: any | null;
      readonly position?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly bookmarks: ReadonlyArray<{
        readonly content_id: string;
        readonly content_type: string;
        readonly created_at?: string | null;
        readonly folder_id?: string | null;
        readonly id: string;
        readonly metadata?: Record<string, any> | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
    }>;
  } | null;
};

export type CreateOneBookmarkFolderMutationVariables = Exact<{
  object: BookmarkFoldersInsertInput;
  on_conflict?: InputMaybe<BookmarkFoldersOnConflict>;
}>;

export type CreateOneBookmarkFolderMutationQuery = {
  readonly insert_bookmark_folders_one?: {
    readonly color?: string | null;
    readonly created_at?: string | null;
    readonly id: string;
    readonly is_default?: boolean | null;
    readonly is_favorite?: boolean | null;
    readonly name: string;
    readonly parent_id?: string | null;
    readonly path?: any | null;
    readonly position?: number | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly bookmarks: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly folder_id?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  } | null;
};

export type CreateManyBookmarkMutationVariables = Exact<{
  objects: ReadonlyArray<BookmarksInsertInput> | BookmarksInsertInput;
  on_conflict?: InputMaybe<BookmarksOnConflict>;
}>;

export type CreateManyBookmarkMutationQuery = {
  readonly insert_bookmarks?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly folder_id?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly bookmark_folder?: {
        readonly color?: string | null;
        readonly created_at?: string | null;
        readonly id: string;
        readonly is_default?: boolean | null;
        readonly is_favorite?: boolean | null;
        readonly name: string;
        readonly parent_id?: string | null;
        readonly path?: any | null;
        readonly position?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      } | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null;
};

export type CreateOneBookmarkMutationVariables = Exact<{
  object: BookmarksInsertInput;
  on_conflict?: InputMaybe<BookmarksOnConflict>;
}>;

export type CreateOneBookmarkMutationQuery = {
  readonly insert_bookmarks_one?: {
    readonly content_id: string;
    readonly content_type: string;
    readonly created_at?: string | null;
    readonly folder_id?: string | null;
    readonly id: string;
    readonly metadata?: Record<string, any> | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly bookmark_folder?: {
      readonly color?: string | null;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_default?: boolean | null;
      readonly is_favorite?: boolean | null;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly path?: any | null;
      readonly position?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    } | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type CreateManyBusinessDomainMutationVariables = Exact<{
  objects:
    | ReadonlyArray<BusinessDomainsInsertInput>
    | BusinessDomainsInsertInput;
  on_conflict?: InputMaybe<BusinessDomainsOnConflict>;
}>;

export type CreateManyBusinessDomainMutationQuery = {
  readonly insert_business_domains?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly id: string;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly slug: string;
      readonly updated_at?: string | null;
      readonly categorized_urls: ReadonlyArray<{
        readonly categorizer_version: string;
        readonly company_id?: string | null;
        readonly confidence: number;
        readonly content_hash?: string | null;
        readonly created_at?: string | null;
        readonly domain_id: string;
        readonly found_on?: string | null;
        readonly id: string;
        readonly priority?: any | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
    }>;
  } | null;
};

export type CreateOneBusinessDomainMutationVariables = Exact<{
  object: BusinessDomainsInsertInput;
  on_conflict?: InputMaybe<BusinessDomainsOnConflict>;
}>;

export type CreateOneBusinessDomainMutationQuery = {
  readonly insert_business_domains_one?: {
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly id: string;
    readonly name: string;
    readonly parent_id?: string | null;
    readonly slug: string;
    readonly updated_at?: string | null;
    readonly categorized_urls: ReadonlyArray<{
      readonly categorizer_version: string;
      readonly company_id?: string | null;
      readonly confidence: number;
      readonly content_hash?: string | null;
      readonly created_at?: string | null;
      readonly domain_id: string;
      readonly found_on?: string | null;
      readonly id: string;
      readonly priority?: any | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
  } | null;
};

export type CreateManyCategoryMutationVariables = Exact<{
  objects: ReadonlyArray<CategoriesInsertInput> | CategoriesInsertInput;
  on_conflict?: InputMaybe<CategoriesOnConflict>;
}>;

export type CreateManyCategoryMutationQuery = {
  readonly insert_categories?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
      readonly companies: ReadonlyArray<{
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
      readonly content_categories: ReadonlyArray<{
        readonly category_id: number;
        readonly content_id: string;
        readonly is_primary: boolean;
      }>;
      readonly feed_categories: ReadonlyArray<{
        readonly category_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly news: ReadonlyArray<{
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
    }>;
  } | null;
};

export type CreateOneCategoryMutationVariables = Exact<{
  object: CategoriesInsertInput;
  on_conflict?: InputMaybe<CategoriesOnConflict>;
}>;

export type CreateOneCategoryMutationQuery = {
  readonly insert_categories_one?: {
    readonly body?: string | null;
    readonly created_at: string;
    readonly document_id?: string | null;
    readonly id: number;
    readonly locale?: string | null;
    readonly name: string;
    readonly published_at?: string | null;
    readonly updated_at?: string | null;
    readonly companies: ReadonlyArray<{
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
    readonly content_categories: ReadonlyArray<{
      readonly category_id: number;
      readonly content_id: string;
      readonly is_primary: boolean;
    }>;
    readonly feed_categories: ReadonlyArray<{
      readonly category_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly news: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
  } | null;
};

export type CreateManyCategorizedUrlMutationVariables = Exact<{
  objects:
    | ReadonlyArray<CategorizedUrlsInsertInput>
    | CategorizedUrlsInsertInput;
  on_conflict?: InputMaybe<CategorizedUrlsOnConflict>;
}>;

export type CreateManyCategorizedUrlMutationQuery = {
  readonly insert_categorized_urls?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly categorizer_version: string;
      readonly company_id?: string | null;
      readonly confidence: number;
      readonly content_hash?: string | null;
      readonly created_at?: string | null;
      readonly domain_id: string;
      readonly found_on?: string | null;
      readonly id: string;
      readonly priority?: any | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly business_domain: {
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly id: string;
        readonly name: string;
        readonly parent_id?: string | null;
        readonly slug: string;
        readonly updated_at?: string | null;
      };
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null;
};

export type CreateOneCategorizedUrlMutationVariables = Exact<{
  object: CategorizedUrlsInsertInput;
  on_conflict?: InputMaybe<CategorizedUrlsOnConflict>;
}>;

export type CreateOneCategorizedUrlMutationQuery = {
  readonly insert_categorized_urls_one?: {
    readonly categorizer_version: string;
    readonly company_id?: string | null;
    readonly confidence: number;
    readonly content_hash?: string | null;
    readonly created_at?: string | null;
    readonly domain_id: string;
    readonly found_on?: string | null;
    readonly id: string;
    readonly priority?: any | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly business_domain: {
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly id: string;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly slug: string;
      readonly updated_at?: string | null;
    };
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type CreateManyCircuitBreakerStateMutationVariables = Exact<{
  objects:
    | ReadonlyArray<CircuitBreakerStatesInsertInput>
    | CircuitBreakerStatesInsertInput;
  on_conflict?: InputMaybe<CircuitBreakerStatesOnConflict>;
}>;

export type CreateManyCircuitBreakerStateMutationQuery = {
  readonly insert_circuit_breaker_states?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly failure_count?: number | null;
      readonly id: string;
      readonly job_name: string;
      readonly last_failure?: string | null;
      readonly last_success?: string | null;
      readonly state: string;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type CreateOneCircuitBreakerStateMutationVariables = Exact<{
  object: CircuitBreakerStatesInsertInput;
  on_conflict?: InputMaybe<CircuitBreakerStatesOnConflict>;
}>;

export type CreateOneCircuitBreakerStateMutationQuery = {
  readonly insert_circuit_breaker_states_one?: {
    readonly created_at?: string | null;
    readonly failure_count?: number | null;
    readonly id: string;
    readonly job_name: string;
    readonly last_failure?: string | null;
    readonly last_success?: string | null;
    readonly state: string;
    readonly updated_at?: string | null;
  } | null;
};

export type CreateManyCityMutationVariables = Exact<{
  objects: ReadonlyArray<CitiesInsertInput> | CitiesInsertInput;
  on_conflict?: InputMaybe<CitiesOnConflict>;
}>;

export type CreateManyCityMutationQuery = {
  readonly insert_cities?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly country_id: number;
      readonly id: number;
      readonly name: string;
      readonly state?: string | null;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly country: {
        readonly code: string;
        readonly code_3?: string | null;
        readonly id: number;
        readonly name: string;
      };
    }>;
  } | null;
};

export type CreateOneCityMutationVariables = Exact<{
  object: CitiesInsertInput;
  on_conflict?: InputMaybe<CitiesOnConflict>;
}>;

export type CreateOneCityMutationQuery = {
  readonly insert_cities_one?: {
    readonly country_id: number;
    readonly id: number;
    readonly name: string;
    readonly state?: string | null;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly country: {
      readonly code: string;
      readonly code_3?: string | null;
      readonly id: number;
      readonly name: string;
    };
  } | null;
};

export type CreateManyCommentMutationVariables = Exact<{
  objects: ReadonlyArray<CommentsInsertInput> | CommentsInsertInput;
  on_conflict?: InputMaybe<CommentsOnConflict>;
}>;

export type CreateManyCommentMutationQuery = {
  readonly insert_comments?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content: string;
      readonly content_id: string;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly parent_comment_id?: string | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneCommentMutationVariables = Exact<{
  object: CommentsInsertInput;
  on_conflict?: InputMaybe<CommentsOnConflict>;
}>;

export type CreateOneCommentMutationQuery = {
  readonly insert_comments_one?: {
    readonly content: string;
    readonly content_id: string;
    readonly content_type: any;
    readonly created_at?: string | null;
    readonly id: string;
    readonly parent_comment_id?: string | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type CreateManyCompanyMutationVariables = Exact<{
  objects: ReadonlyArray<CompaniesInsertInput> | CompaniesInsertInput;
  on_conflict?: InputMaybe<CompaniesOnConflict>;
}>;

export type CreateManyCompanyMutationQuery = {
  readonly insert_companies?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly ads: ReadonlyArray<{
        readonly active?: boolean | null;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly id: string;
        readonly package_id?: string | null;
        readonly start_date: string;
        readonly updated_at?: string | null;
      }>;
      readonly blacklisted_urls: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly id: number;
        readonly reason?: string | null;
        readonly url: string;
      }>;
      readonly categorized_urls: ReadonlyArray<{
        readonly categorizer_version: string;
        readonly company_id?: string | null;
        readonly confidence: number;
        readonly content_hash?: string | null;
        readonly created_at?: string | null;
        readonly domain_id: string;
        readonly found_on?: string | null;
        readonly id: string;
        readonly priority?: any | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
      readonly categoryByCategoryId?: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly company_contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_id: number;
        readonly created_at: string;
        readonly id: number;
        readonly updated_at: string;
      }>;
      readonly company_extras: ReadonlyArray<{
        readonly body?: string | null;
        readonly category: string;
        readonly company_id?: string | null;
        readonly created_at: string;
        readonly found_count?: number | null;
        readonly id: number;
        readonly level: any;
        readonly review?: Record<string, any> | null;
        readonly success?: boolean | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
      readonly contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_type?: any | null;
        readonly created_at?: string | null;
        readonly email?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly phone?: string | null;
        readonly privacy_level?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly content_sources: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly expected_count?: any | null;
        readonly failed_count?: any | null;
        readonly has_failed?: boolean | null;
        readonly hash?: number | null;
        readonly id: number;
        readonly priority: any;
        readonly refreshed_at?: string | null;
        readonly rss_urls?: ReadonlyArray<string> | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
      readonly news: ReadonlyArray<{
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
      readonly social_medium?: {
        readonly created_at?: string | null;
        readonly facebook_url?: string | null;
        readonly id: number;
        readonly instagram_url?: string | null;
        readonly linkedin_url?: string | null;
        readonly twitter_url?: string | null;
        readonly updated_at?: string | null;
        readonly youtube_url?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneCompanyMutationVariables = Exact<{
  object: CompaniesInsertInput;
  on_conflict?: InputMaybe<CompaniesOnConflict>;
}>;

export type CreateOneCompanyMutationQuery = {
  readonly insert_companies_one?: {
    readonly category?: string | null;
    readonly category_id?: number | null;
    readonly content_status: any;
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly failed_count?: any | null;
    readonly founding_year?: any | null;
    readonly id: string;
    readonly is_english?: boolean | null;
    readonly is_government?: boolean | null;
    readonly keywords?: Record<string, any> | null;
    readonly logo_url?: string | null;
    readonly name?: string | null;
    readonly scrape_frequency?: any | null;
    readonly scrape_rating?: any | null;
    readonly scraped_at?: string | null;
    readonly social_media_id?: number | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly ads: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    }>;
    readonly blacklisted_urls: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly id: number;
      readonly reason?: string | null;
      readonly url: string;
    }>;
    readonly categorized_urls: ReadonlyArray<{
      readonly categorizer_version: string;
      readonly company_id?: string | null;
      readonly confidence: number;
      readonly content_hash?: string | null;
      readonly created_at?: string | null;
      readonly domain_id: string;
      readonly found_on?: string | null;
      readonly id: string;
      readonly priority?: any | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
    readonly categoryByCategoryId?: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly company_contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_id: number;
      readonly created_at: string;
      readonly id: number;
      readonly updated_at: string;
    }>;
    readonly company_extras: ReadonlyArray<{
      readonly body?: string | null;
      readonly category: string;
      readonly company_id?: string | null;
      readonly created_at: string;
      readonly found_count?: number | null;
      readonly id: number;
      readonly level: any;
      readonly review?: Record<string, any> | null;
      readonly success?: boolean | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
    readonly contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly content_sources: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
    readonly news: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
    readonly social_medium?: {
      readonly created_at?: string | null;
      readonly facebook_url?: string | null;
      readonly id: number;
      readonly instagram_url?: string | null;
      readonly linkedin_url?: string | null;
      readonly twitter_url?: string | null;
      readonly updated_at?: string | null;
      readonly youtube_url?: string | null;
    } | null;
  } | null;
};

export type CreateManyCompanyContactMutationVariables = Exact<{
  objects:
    | ReadonlyArray<CompanyContactsInsertInput>
    | CompanyContactsInsertInput;
  on_conflict?: InputMaybe<CompanyContactsOnConflict>;
}>;

export type CreateManyCompanyContactMutationQuery = {
  readonly insert_company_contacts?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_id: number;
      readonly created_at: string;
      readonly id: number;
      readonly updated_at: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly contact: {
        readonly company_id?: string | null;
        readonly contact_type?: any | null;
        readonly created_at?: string | null;
        readonly email?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly phone?: string | null;
        readonly privacy_level?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneCompanyContactMutationVariables = Exact<{
  object: CompanyContactsInsertInput;
  on_conflict?: InputMaybe<CompanyContactsOnConflict>;
}>;

export type CreateOneCompanyContactMutationQuery = {
  readonly insert_company_contacts_one?: {
    readonly company_id?: string | null;
    readonly contact_id: number;
    readonly created_at: string;
    readonly id: number;
    readonly updated_at: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly contact: {
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    };
  } | null;
};

export type CreateManyCompanyEmployeeMutationVariables = Exact<{
  objects:
    | ReadonlyArray<CompanyEmployeesInsertInput>
    | CompanyEmployeesInsertInput;
  on_conflict?: InputMaybe<CompanyEmployeesOnConflict>;
}>;

export type CreateManyCompanyEmployeeMutationQuery = {
  readonly insert_company_employees?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly access_level: any;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date?: string | null;
      readonly id: string;
      readonly job_description?: string | null;
      readonly role: string;
      readonly start_date?: string | null;
      readonly status?: boolean | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneCompanyEmployeeMutationVariables = Exact<{
  object: CompanyEmployeesInsertInput;
  on_conflict?: InputMaybe<CompanyEmployeesOnConflict>;
}>;

export type CreateOneCompanyEmployeeMutationQuery = {
  readonly insert_company_employees_one?: {
    readonly access_level: any;
    readonly company_id?: string | null;
    readonly created_at?: string | null;
    readonly end_date?: string | null;
    readonly id: string;
    readonly job_description?: string | null;
    readonly role: string;
    readonly start_date?: string | null;
    readonly status?: boolean | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type CreateManyCompanyExtraMutationVariables = Exact<{
  objects: ReadonlyArray<CompanyExtrasInsertInput> | CompanyExtrasInsertInput;
  on_conflict?: InputMaybe<CompanyExtrasOnConflict>;
}>;

export type CreateManyCompanyExtraMutationQuery = {
  readonly insert_company_extras?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly body?: string | null;
      readonly category: string;
      readonly company_id?: string | null;
      readonly created_at: string;
      readonly found_count?: number | null;
      readonly id: number;
      readonly level: any;
      readonly review?: Record<string, any> | null;
      readonly success?: boolean | null;
      readonly updated_at: string;
      readonly url: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null;
};

export type CreateOneCompanyExtraMutationVariables = Exact<{
  object: CompanyExtrasInsertInput;
  on_conflict?: InputMaybe<CompanyExtrasOnConflict>;
}>;

export type CreateOneCompanyExtraMutationQuery = {
  readonly insert_company_extras_one?: {
    readonly body?: string | null;
    readonly category: string;
    readonly company_id?: string | null;
    readonly created_at: string;
    readonly found_count?: number | null;
    readonly id: number;
    readonly level: any;
    readonly review?: Record<string, any> | null;
    readonly success?: boolean | null;
    readonly updated_at: string;
    readonly url: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type CreateManyCompanyMetricMutationVariables = Exact<{
  objects: ReadonlyArray<CompanyMetricsInsertInput> | CompanyMetricsInsertInput;
  on_conflict?: InputMaybe<CompanyMetricsOnConflict>;
}>;

export type CreateManyCompanyMetricMutationQuery = {
  readonly insert_company_metrics?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id: string;
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
      readonly metric_definition?: {
        readonly category?: string | null;
        readonly description?: string | null;
        readonly id: number;
        readonly is_dimensional?: boolean | null;
        readonly name: string;
        readonly type: string;
        readonly unit?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneCompanyMetricMutationVariables = Exact<{
  object: CompanyMetricsInsertInput;
  on_conflict?: InputMaybe<CompanyMetricsOnConflict>;
}>;

export type CreateOneCompanyMetricMutationQuery = {
  readonly insert_company_metrics_one?: {
    readonly company_id: string;
    readonly crawl_id: string;
    readonly id: number;
    readonly metric_id?: number | null;
    readonly timestamp: string;
    readonly value: Record<string, any>;
    readonly metric_definition?: {
      readonly category?: string | null;
      readonly description?: string | null;
      readonly id: number;
      readonly is_dimensional?: boolean | null;
      readonly name: string;
      readonly type: string;
      readonly unit?: string | null;
    } | null;
  } | null;
};

export type CreateManyContactMutationVariables = Exact<{
  objects: ReadonlyArray<ContactsInsertInput> | ContactsInsertInput;
  on_conflict?: InputMaybe<ContactsOnConflict>;
}>;

export type CreateManyContactMutationQuery = {
  readonly insert_contacts?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly company_contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_id: number;
        readonly created_at: string;
        readonly id: number;
        readonly updated_at: string;
      }>;
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneContactMutationVariables = Exact<{
  object: ContactsInsertInput;
  on_conflict?: InputMaybe<ContactsOnConflict>;
}>;

export type CreateOneContactMutationQuery = {
  readonly insert_contacts_one?: {
    readonly company_id?: string | null;
    readonly contact_type?: any | null;
    readonly created_at?: string | null;
    readonly email?: string | null;
    readonly id: number;
    readonly is_primary?: boolean | null;
    readonly phone?: string | null;
    readonly privacy_level?: any | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly user_id?: string | null;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly company_contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_id: number;
      readonly created_at: string;
      readonly id: number;
      readonly updated_at: string;
    }>;
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type CreateManyContentCategoryMutationVariables = Exact<{
  objects:
    | ReadonlyArray<ContentCategoriesInsertInput>
    | ContentCategoriesInsertInput;
  on_conflict?: InputMaybe<ContentCategoriesOnConflict>;
}>;

export type CreateManyContentCategoryMutationQuery = {
  readonly insert_content_categories?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category_id: number;
      readonly content_id: string;
      readonly is_primary: boolean;
      readonly category: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      };
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null;
};

export type CreateOneContentCategoryMutationVariables = Exact<{
  object: ContentCategoriesInsertInput;
  on_conflict?: InputMaybe<ContentCategoriesOnConflict>;
}>;

export type CreateOneContentCategoryMutationQuery = {
  readonly insert_content_categories_one?: {
    readonly category_id: number;
    readonly content_id: string;
    readonly is_primary: boolean;
    readonly category: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    };
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type CreateManyContentSourceVisitMutationVariables = Exact<{
  objects:
    | ReadonlyArray<ContentSourceVisitsInsertInput>
    | ContentSourceVisitsInsertInput;
  on_conflict?: InputMaybe<ContentSourceVisitsOnConflict>;
}>;

export type CreateManyContentSourceVisitMutationQuery = {
  readonly insert_content_source_visits?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneContentSourceVisitMutationVariables = Exact<{
  object: ContentSourceVisitsInsertInput;
  on_conflict?: InputMaybe<ContentSourceVisitsOnConflict>;
}>;

export type CreateOneContentSourceVisitMutationQuery = {
  readonly insert_content_source_visits_one?: {
    readonly content_id: string;
    readonly created_at?: string | null;
    readonly id: string;
    readonly user_id?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type CreateManyContentSourceMutationVariables = Exact<{
  objects: ReadonlyArray<ContentSourcesInsertInput> | ContentSourcesInsertInput;
  on_conflict?: InputMaybe<ContentSourcesOnConflict>;
}>;

export type CreateManyContentSourceMutationQuery = {
  readonly insert_content_sources?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly feed_sources: ReadonlyArray<{
        readonly content_source_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly news: ReadonlyArray<{
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
    }>;
  } | null;
};

export type CreateOneContentSourceMutationVariables = Exact<{
  object: ContentSourcesInsertInput;
  on_conflict?: InputMaybe<ContentSourcesOnConflict>;
}>;

export type CreateOneContentSourceMutationQuery = {
  readonly insert_content_sources_one?: {
    readonly company_id?: string | null;
    readonly content_type: any;
    readonly created_at?: string | null;
    readonly expected_count?: any | null;
    readonly failed_count?: any | null;
    readonly has_failed?: boolean | null;
    readonly hash?: number | null;
    readonly id: number;
    readonly priority: any;
    readonly refreshed_at?: string | null;
    readonly rss_urls?: ReadonlyArray<string> | null;
    readonly scrape_frequency: any;
    readonly scraped_at?: string | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly feed_sources: ReadonlyArray<{
      readonly content_source_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly news: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
  } | null;
};

export type CreateManyContentStatusMutationVariables = Exact<{
  objects:
    | ReadonlyArray<ContentStatusesInsertInput>
    | ContentStatusesInsertInput;
  on_conflict?: InputMaybe<ContentStatusesOnConflict>;
}>;

export type CreateManyContentStatusMutationQuery = {
  readonly insert_content_statuses?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly notes?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null;
};

export type CreateOneContentStatusMutationVariables = Exact<{
  object: ContentStatusesInsertInput;
  on_conflict?: InputMaybe<ContentStatusesOnConflict>;
}>;

export type CreateOneContentStatusMutationQuery = {
  readonly insert_content_statuses_one?: {
    readonly content_id: string;
    readonly content_status: any;
    readonly created_at?: string | null;
    readonly id: string;
    readonly notes?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type CreateManyContentTagMutationVariables = Exact<{
  objects: ReadonlyArray<ContentTagsInsertInput> | ContentTagsInsertInput;
  on_conflict?: InputMaybe<ContentTagsOnConflict>;
}>;

export type CreateManyContentTagMutationQuery = {
  readonly insert_content_tags?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly tag_id: number;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly tag: {
        readonly body?: string | null;
        readonly created_at?: string | null;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneContentTagMutationVariables = Exact<{
  object: ContentTagsInsertInput;
  on_conflict?: InputMaybe<ContentTagsOnConflict>;
}>;

export type CreateOneContentTagMutationQuery = {
  readonly insert_content_tags_one?: {
    readonly content_id: string;
    readonly tag_id: number;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly tag: {
      readonly body?: string | null;
      readonly created_at?: string | null;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    };
  } | null;
};

export type CreateManyContentMutationVariables = Exact<{
  objects: ReadonlyArray<ContentsInsertInput> | ContentsInsertInput;
  on_conflict?: InputMaybe<ContentsOnConflict>;
}>;

export type CreateManyContentMutationQuery = {
  readonly insert_contents?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly bookmarks: ReadonlyArray<{
        readonly content_id: string;
        readonly content_type: string;
        readonly created_at?: string | null;
        readonly folder_id?: string | null;
        readonly id: string;
        readonly metadata?: Record<string, any> | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly content_categories: ReadonlyArray<{
        readonly category_id: number;
        readonly content_id: string;
        readonly is_primary: boolean;
      }>;
      readonly content_source_visits: ReadonlyArray<{
        readonly content_id: string;
        readonly created_at?: string | null;
        readonly id: string;
        readonly user_id?: string | null;
      }>;
      readonly content_statuses: ReadonlyArray<{
        readonly content_id: string;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly id: string;
        readonly notes?: string | null;
      }>;
      readonly content_tags: ReadonlyArray<{
        readonly content_id: string;
        readonly tag_id: number;
      }>;
      readonly news?: {
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      } | null;
      readonly newsletter?: {
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly frequency: string;
        readonly generated_content?: string | null;
        readonly id: string;
        readonly start_date: string;
        readonly title: string;
        readonly updated_at?: string | null;
      } | null;
      readonly research?: {
        readonly abstract?: string | null;
        readonly abstract_url: string;
        readonly affiliations?: Record<string, any> | null;
        readonly authors?: Record<string, any> | null;
        readonly category?: string | null;
        readonly comments?: string | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly doi_url?: string | null;
        readonly figure_count?: any | null;
        readonly has_embedding?: boolean | null;
        readonly id: string;
        readonly is_flagged: boolean;
        readonly keywords?: string | null;
        readonly month?: string | null;
        readonly page_count?: any | null;
        readonly pdf_url?: string | null;
        readonly published_at?: string | null;
        readonly published_in?: string | null;
        readonly summary?: string | null;
        readonly table_count?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly version?: any | null;
        readonly year?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneContentMutationVariables = Exact<{
  object: ContentsInsertInput;
  on_conflict?: InputMaybe<ContentsOnConflict>;
}>;

export type CreateOneContentMutationQuery = {
  readonly insert_contents_one?: {
    readonly content_type: any;
    readonly created_at?: string | null;
    readonly hot_score?: any | null;
    readonly id: string;
    readonly rss_url?: string | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly bookmarks: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly folder_id?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly content_categories: ReadonlyArray<{
      readonly category_id: number;
      readonly content_id: string;
      readonly is_primary: boolean;
    }>;
    readonly content_source_visits: ReadonlyArray<{
      readonly content_id: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id?: string | null;
    }>;
    readonly content_statuses: ReadonlyArray<{
      readonly content_id: string;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly notes?: string | null;
    }>;
    readonly content_tags: ReadonlyArray<{
      readonly content_id: string;
      readonly tag_id: number;
    }>;
    readonly news?: {
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    } | null;
    readonly newsletter?: {
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly frequency: string;
      readonly generated_content?: string | null;
      readonly id: string;
      readonly start_date: string;
      readonly title: string;
      readonly updated_at?: string | null;
    } | null;
    readonly research?: {
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
    } | null;
  } | null;
};

export type CreateManyCountryMutationVariables = Exact<{
  objects: ReadonlyArray<CountriesInsertInput> | CountriesInsertInput;
  on_conflict?: InputMaybe<CountriesOnConflict>;
}>;

export type CreateManyCountryMutationQuery = {
  readonly insert_countries?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly code: string;
      readonly code_3?: string | null;
      readonly id: number;
      readonly name: string;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly cities: ReadonlyArray<{
        readonly country_id: number;
        readonly id: number;
        readonly name: string;
        readonly state?: string | null;
      }>;
    }>;
  } | null;
};

export type CreateOneCountryMutationVariables = Exact<{
  object: CountriesInsertInput;
  on_conflict?: InputMaybe<CountriesOnConflict>;
}>;

export type CreateOneCountryMutationQuery = {
  readonly insert_countries_one?: {
    readonly code: string;
    readonly code_3?: string | null;
    readonly id: number;
    readonly name: string;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly cities: ReadonlyArray<{
      readonly country_id: number;
      readonly id: number;
      readonly name: string;
      readonly state?: string | null;
    }>;
  } | null;
};

export type CreateManyCustomerPaymentMutationVariables = Exact<{
  objects:
    | ReadonlyArray<CustomerPaymentsInsertInput>
    | CustomerPaymentsInsertInput;
  on_conflict?: InputMaybe<CustomerPaymentsOnConflict>;
}>;

export type CreateManyCustomerPaymentMutationQuery = {
  readonly insert_customer_payments?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
      readonly customer_refunds: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly batch_id?: string | null;
        readonly created_at?: string | null;
        readonly currency?: string | null;
        readonly external_refund_id: string;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly payment_id: number;
        readonly receipt?: string | null;
        readonly speed_processed?: string | null;
        readonly speed_requested?: string | null;
        readonly status: string;
      }>;
      readonly customer_subscription?: {
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      } | null;
      readonly payment_provider: {
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_active?: boolean | null;
        readonly name: string;
        readonly updated_at?: string | null;
      };
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneCustomerPaymentMutationVariables = Exact<{
  object: CustomerPaymentsInsertInput;
  on_conflict?: InputMaybe<CustomerPaymentsOnConflict>;
}>;

export type CreateOneCustomerPaymentMutationQuery = {
  readonly insert_customer_payments_one?: {
    readonly acquirer_data?: Record<string, any> | null;
    readonly amount: number;
    readonly amount_refunded?: number | null;
    readonly amount_transferred?: number | null;
    readonly bank?: string | null;
    readonly captured?: boolean | null;
    readonly created_at?: string | null;
    readonly currency: string;
    readonly description?: string | null;
    readonly error_code?: string | null;
    readonly error_description?: string | null;
    readonly error_reason?: string | null;
    readonly error_source?: string | null;
    readonly error_step?: string | null;
    readonly external_order_id?: string | null;
    readonly external_payment_id: string;
    readonly fee?: number | null;
    readonly id: number;
    readonly international?: boolean | null;
    readonly invoice_id?: string | null;
    readonly method?: string | null;
    readonly notes?: Record<string, any> | null;
    readonly order_id?: string | null;
    readonly payment_provider_id: number;
    readonly refund_status?: string | null;
    readonly status: string;
    readonly subscription_id?: number | null;
    readonly tax?: number | null;
    readonly user_id: string;
    readonly vpa?: string | null;
    readonly wallet?: string | null;
    readonly customer_refunds: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly batch_id?: string | null;
      readonly created_at?: string | null;
      readonly currency?: string | null;
      readonly external_refund_id: string;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly payment_id: number;
      readonly receipt?: string | null;
      readonly speed_processed?: string | null;
      readonly speed_requested?: string | null;
      readonly status: string;
    }>;
    readonly customer_subscription?: {
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    } | null;
    readonly payment_provider: {
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_active?: boolean | null;
      readonly name: string;
      readonly updated_at?: string | null;
    };
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type CreateManyCustomerProcessedWebhookMutationVariables = Exact<{
  objects:
    | ReadonlyArray<CustomerProcessedWebhooksInsertInput>
    | CustomerProcessedWebhooksInsertInput;
  on_conflict?: InputMaybe<CustomerProcessedWebhooksOnConflict>;
}>;

export type CreateManyCustomerProcessedWebhookMutationQuery = {
  readonly insert_customer_processed_webhooks?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly event_id: string;
      readonly event_type: string;
      readonly id: number;
      readonly processed_at: string;
    }>;
  } | null;
};

export type CreateOneCustomerProcessedWebhookMutationVariables = Exact<{
  object: CustomerProcessedWebhooksInsertInput;
  on_conflict?: InputMaybe<CustomerProcessedWebhooksOnConflict>;
}>;

export type CreateOneCustomerProcessedWebhookMutationQuery = {
  readonly insert_customer_processed_webhooks_one?: {
    readonly event_id: string;
    readonly event_type: string;
    readonly id: number;
    readonly processed_at: string;
  } | null;
};

export type CreateManyCustomerRefundMutationVariables = Exact<{
  objects:
    | ReadonlyArray<CustomerRefundsInsertInput>
    | CustomerRefundsInsertInput;
  on_conflict?: InputMaybe<CustomerRefundsOnConflict>;
}>;

export type CreateManyCustomerRefundMutationQuery = {
  readonly insert_customer_refunds?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly batch_id?: string | null;
      readonly created_at?: string | null;
      readonly currency?: string | null;
      readonly external_refund_id: string;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly payment_id: number;
      readonly receipt?: string | null;
      readonly speed_processed?: string | null;
      readonly speed_requested?: string | null;
      readonly status: string;
      readonly customer_payment: {
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneCustomerRefundMutationVariables = Exact<{
  object: CustomerRefundsInsertInput;
  on_conflict?: InputMaybe<CustomerRefundsOnConflict>;
}>;

export type CreateOneCustomerRefundMutationQuery = {
  readonly insert_customer_refunds_one?: {
    readonly acquirer_data?: Record<string, any> | null;
    readonly amount: number;
    readonly batch_id?: string | null;
    readonly created_at?: string | null;
    readonly currency?: string | null;
    readonly external_refund_id: string;
    readonly id: number;
    readonly notes?: Record<string, any> | null;
    readonly payment_id: number;
    readonly receipt?: string | null;
    readonly speed_processed?: string | null;
    readonly speed_requested?: string | null;
    readonly status: string;
    readonly customer_payment: {
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    };
  } | null;
};

export type CreateManyCustomerSubscriptionPlanMutationVariables = Exact<{
  objects:
    | ReadonlyArray<CustomerSubscriptionPlansInsertInput>
    | CustomerSubscriptionPlansInsertInput;
  on_conflict?: InputMaybe<CustomerSubscriptionPlansOnConflict>;
}>;

export type CreateManyCustomerSubscriptionPlanMutationQuery = {
  readonly insert_customer_subscription_plans?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly annual_amount: number;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly external_plan_id?: string | null;
      readonly features?: Record<string, any> | null;
      readonly id: number;
      readonly interval: number;
      readonly interval_type: string;
      readonly is_active?: boolean | null;
      readonly monthly_amount: number;
      readonly name: string;
      readonly updated_at?: string | null;
      readonly customer_subscriptions: ReadonlyArray<{
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
    }>;
  } | null;
};

export type CreateOneCustomerSubscriptionPlanMutationVariables = Exact<{
  object: CustomerSubscriptionPlansInsertInput;
  on_conflict?: InputMaybe<CustomerSubscriptionPlansOnConflict>;
}>;

export type CreateOneCustomerSubscriptionPlanMutationQuery = {
  readonly insert_customer_subscription_plans_one?: {
    readonly annual_amount: number;
    readonly created_at?: string | null;
    readonly currency: string;
    readonly description?: string | null;
    readonly external_plan_id?: string | null;
    readonly features?: Record<string, any> | null;
    readonly id: number;
    readonly interval: number;
    readonly interval_type: string;
    readonly is_active?: boolean | null;
    readonly monthly_amount: number;
    readonly name: string;
    readonly updated_at?: string | null;
    readonly customer_subscriptions: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  } | null;
};

export type CreateManyCustomerSubscriptionMutationVariables = Exact<{
  objects:
    | ReadonlyArray<CustomerSubscriptionsInsertInput>
    | CustomerSubscriptionsInsertInput;
  on_conflict?: InputMaybe<CustomerSubscriptionsOnConflict>;
}>;

export type CreateManyCustomerSubscriptionMutationQuery = {
  readonly insert_customer_subscriptions?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly customer_payments: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      }>;
      readonly customer_subscription_plan: {
        readonly annual_amount: number;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly external_plan_id?: string | null;
        readonly features?: Record<string, any> | null;
        readonly id: number;
        readonly interval: number;
        readonly interval_type: string;
        readonly is_active?: boolean | null;
        readonly monthly_amount: number;
        readonly name: string;
        readonly updated_at?: string | null;
      };
      readonly payment_provider: {
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_active?: boolean | null;
        readonly name: string;
        readonly updated_at?: string | null;
      };
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneCustomerSubscriptionMutationVariables = Exact<{
  object: CustomerSubscriptionsInsertInput;
  on_conflict?: InputMaybe<CustomerSubscriptionsOnConflict>;
}>;

export type CreateOneCustomerSubscriptionMutationQuery = {
  readonly insert_customer_subscriptions_one?: {
    readonly auth_attempts?: number | null;
    readonly cancel_at_period_end?: boolean | null;
    readonly cancel_initiated_by?: string | null;
    readonly change_scheduled_at?: string | null;
    readonly charge_at?: string | null;
    readonly created_at?: string | null;
    readonly current_end: string;
    readonly current_start: string;
    readonly customer_notify?: boolean | null;
    readonly end_at?: string | null;
    readonly ended_at?: string | null;
    readonly expire_by?: string | null;
    readonly external_subscription_id: string;
    readonly has_scheduled_changes?: boolean | null;
    readonly id: number;
    readonly notes?: Record<string, any> | null;
    readonly offer_id?: string | null;
    readonly paid_count?: number | null;
    readonly pause_initiated_by?: string | null;
    readonly payment_provider_id: number;
    readonly plan_id: number;
    readonly quantity?: number | null;
    readonly remaining_count?: number | null;
    readonly short_url?: string | null;
    readonly source?: string | null;
    readonly start_at?: string | null;
    readonly status: string;
    readonly total_count?: number | null;
    readonly type?: number | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly customer_payments: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
    readonly customer_subscription_plan: {
      readonly annual_amount: number;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly external_plan_id?: string | null;
      readonly features?: Record<string, any> | null;
      readonly id: number;
      readonly interval: number;
      readonly interval_type: string;
      readonly is_active?: boolean | null;
      readonly monthly_amount: number;
      readonly name: string;
      readonly updated_at?: string | null;
    };
    readonly payment_provider: {
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_active?: boolean | null;
      readonly name: string;
      readonly updated_at?: string | null;
    };
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type CreateManyEmbeddingReviewMutationVariables = Exact<{
  objects:
    | ReadonlyArray<EmbeddingReviewsInsertInput>
    | EmbeddingReviewsInsertInput;
  on_conflict?: InputMaybe<EmbeddingReviewsOnConflict>;
}>;

export type CreateManyEmbeddingReviewMutationQuery = {
  readonly insert_embedding_reviews?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly agent_review?: boolean | null;
      readonly created_at: string;
      readonly human_review?: boolean | null;
      readonly id: number;
      readonly notes?: string | null;
      readonly updated_at?: string | null;
      readonly research_embeddings: ReadonlyArray<{
        readonly chunk: string;
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly embedding_review_id?: number | null;
        readonly id: number;
        readonly is_flagged?: boolean | null;
        readonly research_id: string;
        readonly updated_at: string;
        readonly url?: string | null;
      }>;
    }>;
  } | null;
};

export type CreateOneEmbeddingReviewMutationVariables = Exact<{
  object: EmbeddingReviewsInsertInput;
  on_conflict?: InputMaybe<EmbeddingReviewsOnConflict>;
}>;

export type CreateOneEmbeddingReviewMutationQuery = {
  readonly insert_embedding_reviews_one?: {
    readonly agent_review?: boolean | null;
    readonly created_at: string;
    readonly human_review?: boolean | null;
    readonly id: number;
    readonly notes?: string | null;
    readonly updated_at?: string | null;
    readonly research_embeddings: ReadonlyArray<{
      readonly chunk: string;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly embedding_review_id?: number | null;
      readonly id: number;
      readonly is_flagged?: boolean | null;
      readonly research_id: string;
      readonly updated_at: string;
      readonly url?: string | null;
    }>;
  } | null;
};

export type CreateManyErrorLogMutationVariables = Exact<{
  objects: ReadonlyArray<ErrorLogsInsertInput> | ErrorLogsInsertInput;
  on_conflict?: InputMaybe<ErrorLogsOnConflict>;
}>;

export type CreateManyErrorLogMutationQuery = {
  readonly insert_error_logs?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly context?: Record<string, any> | null;
      readonly correlation_id?: string | null;
      readonly created_at?: string | null;
      readonly domain?: string | null;
      readonly environment: string;
      readonly error_hash?: string | null;
      readonly error_pattern?: string | null;
      readonly error_type: any;
      readonly frequency_data?: Record<string, any> | null;
      readonly github_repo?: string | null;
      readonly id: string;
      readonly is_new_pattern?: boolean | null;
      readonly message: string;
      readonly metadata?: Record<string, any> | null;
      readonly related_errors?: Record<string, any> | null;
      readonly request_id?: string | null;
      readonly service_name: string;
      readonly severity: any;
      readonly stack_trace?: string | null;
      readonly user_id?: string | null;
    }>;
  } | null;
};

export type CreateOneErrorLogMutationVariables = Exact<{
  object: ErrorLogsInsertInput;
  on_conflict?: InputMaybe<ErrorLogsOnConflict>;
}>;

export type CreateOneErrorLogMutationQuery = {
  readonly insert_error_logs_one?: {
    readonly context?: Record<string, any> | null;
    readonly correlation_id?: string | null;
    readonly created_at?: string | null;
    readonly domain?: string | null;
    readonly environment: string;
    readonly error_hash?: string | null;
    readonly error_pattern?: string | null;
    readonly error_type: any;
    readonly frequency_data?: Record<string, any> | null;
    readonly github_repo?: string | null;
    readonly id: string;
    readonly is_new_pattern?: boolean | null;
    readonly message: string;
    readonly metadata?: Record<string, any> | null;
    readonly related_errors?: Record<string, any> | null;
    readonly request_id?: string | null;
    readonly service_name: string;
    readonly severity: any;
    readonly stack_trace?: string | null;
    readonly user_id?: string | null;
  } | null;
};

export type CreateManyFeatureRequestMutationVariables = Exact<{
  objects:
    | ReadonlyArray<FeatureRequestsInsertInput>
    | FeatureRequestsInsertInput;
  on_conflict?: InputMaybe<FeatureRequestsOnConflict>;
}>;

export type CreateManyFeatureRequestMutationQuery = {
  readonly insert_feature_requests?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly downvotes?: number | null;
      readonly engagement_score?: number | null;
      readonly id: string;
      readonly priority_score?: number | null;
      readonly status: string;
      readonly title: string;
      readonly updated_at?: string | null;
      readonly upvotes?: number | null;
      readonly feature_votes: ReadonlyArray<{
        readonly created_at?: string | null;
        readonly feature_id: string;
        readonly feedback?: string | null;
        readonly id: string;
        readonly updated_at?: string | null;
        readonly user_id: string;
        readonly vote_type: any;
      }>;
    }>;
  } | null;
};

export type CreateOneFeatureRequestMutationVariables = Exact<{
  object: FeatureRequestsInsertInput;
  on_conflict?: InputMaybe<FeatureRequestsOnConflict>;
}>;

export type CreateOneFeatureRequestMutationQuery = {
  readonly insert_feature_requests_one?: {
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly downvotes?: number | null;
    readonly engagement_score?: number | null;
    readonly id: string;
    readonly priority_score?: number | null;
    readonly status: string;
    readonly title: string;
    readonly updated_at?: string | null;
    readonly upvotes?: number | null;
    readonly feature_votes: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly feature_id: string;
      readonly feedback?: string | null;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly vote_type: any;
    }>;
  } | null;
};

export type CreateManyFeatureVoteMutationVariables = Exact<{
  objects: ReadonlyArray<FeatureVotesInsertInput> | FeatureVotesInsertInput;
  on_conflict?: InputMaybe<FeatureVotesOnConflict>;
}>;

export type CreateManyFeatureVoteMutationQuery = {
  readonly insert_feature_votes?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly feature_id: string;
      readonly feedback?: string | null;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly vote_type: any;
      readonly feature_request: {
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly downvotes?: number | null;
        readonly engagement_score?: number | null;
        readonly id: string;
        readonly priority_score?: number | null;
        readonly status: string;
        readonly title: string;
        readonly updated_at?: string | null;
        readonly upvotes?: number | null;
      };
    }>;
  } | null;
};

export type CreateOneFeatureVoteMutationVariables = Exact<{
  object: FeatureVotesInsertInput;
  on_conflict?: InputMaybe<FeatureVotesOnConflict>;
}>;

export type CreateOneFeatureVoteMutationQuery = {
  readonly insert_feature_votes_one?: {
    readonly created_at?: string | null;
    readonly feature_id: string;
    readonly feedback?: string | null;
    readonly id: string;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly vote_type: any;
    readonly feature_request: {
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly downvotes?: number | null;
      readonly engagement_score?: number | null;
      readonly id: string;
      readonly priority_score?: number | null;
      readonly status: string;
      readonly title: string;
      readonly updated_at?: string | null;
      readonly upvotes?: number | null;
    };
  } | null;
};

export type CreateManyFeedCategoryMutationVariables = Exact<{
  objects: ReadonlyArray<FeedCategoriesInsertInput> | FeedCategoriesInsertInput;
  on_conflict?: InputMaybe<FeedCategoriesOnConflict>;
}>;

export type CreateManyFeedCategoryMutationQuery = {
  readonly insert_feed_categories?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
      readonly category?: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly feed?: {
        readonly created_at: string;
        readonly id: string;
        readonly name?: string | null;
        readonly user_id?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneFeedCategoryMutationVariables = Exact<{
  object: FeedCategoriesInsertInput;
  on_conflict?: InputMaybe<FeedCategoriesOnConflict>;
}>;

export type CreateOneFeedCategoryMutationQuery = {
  readonly insert_feed_categories_one?: {
    readonly category_id?: number | null;
    readonly created_at: string;
    readonly feed_id?: string | null;
    readonly id: number;
    readonly category?: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly feed?: {
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    } | null;
  } | null;
};

export type CreateManyFeedSourceMutationVariables = Exact<{
  objects: ReadonlyArray<FeedSourcesInsertInput> | FeedSourcesInsertInput;
  on_conflict?: InputMaybe<FeedSourcesOnConflict>;
}>;

export type CreateManyFeedSourceMutationQuery = {
  readonly insert_feed_sources?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_source_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
      readonly content_source?: {
        readonly company_id?: string | null;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly expected_count?: any | null;
        readonly failed_count?: any | null;
        readonly has_failed?: boolean | null;
        readonly hash?: number | null;
        readonly id: number;
        readonly priority: any;
        readonly refreshed_at?: string | null;
        readonly rss_urls?: ReadonlyArray<string> | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly feed?: {
        readonly created_at: string;
        readonly id: string;
        readonly name?: string | null;
        readonly user_id?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneFeedSourceMutationVariables = Exact<{
  object: FeedSourcesInsertInput;
  on_conflict?: InputMaybe<FeedSourcesOnConflict>;
}>;

export type CreateOneFeedSourceMutationQuery = {
  readonly insert_feed_sources_one?: {
    readonly content_source_id?: number | null;
    readonly created_at: string;
    readonly feed_id?: string | null;
    readonly id: number;
    readonly content_source?: {
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly feed?: {
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    } | null;
  } | null;
};

export type CreateManyFeedbackMutationVariables = Exact<{
  objects: ReadonlyArray<FeedbacksInsertInput> | FeedbacksInsertInput;
  on_conflict?: InputMaybe<FeedbacksOnConflict>;
}>;

export type CreateManyFeedbackMutationQuery = {
  readonly insert_feedbacks?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at: string;
      readonly device_info?: string | null;
      readonly feedback_status?: any | null;
      readonly feedback_type?: any | null;
      readonly id: number;
      readonly message: string;
      readonly page_identifier: string;
      readonly rating?: number | null;
      readonly resolution_comment?: string | null;
      readonly updated_at: string;
      readonly user_id?: string | null;
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneFeedbackMutationVariables = Exact<{
  object: FeedbacksInsertInput;
  on_conflict?: InputMaybe<FeedbacksOnConflict>;
}>;

export type CreateOneFeedbackMutationQuery = {
  readonly insert_feedbacks_one?: {
    readonly created_at: string;
    readonly device_info?: string | null;
    readonly feedback_status?: any | null;
    readonly feedback_type?: any | null;
    readonly id: number;
    readonly message: string;
    readonly page_identifier: string;
    readonly rating?: number | null;
    readonly resolution_comment?: string | null;
    readonly updated_at: string;
    readonly user_id?: string | null;
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type CreateManyFeedMutationVariables = Exact<{
  objects: ReadonlyArray<FeedsInsertInput> | FeedsInsertInput;
  on_conflict?: InputMaybe<FeedsOnConflict>;
}>;

export type CreateManyFeedMutationQuery = {
  readonly insert_feeds?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
      readonly feed_categories: ReadonlyArray<{
        readonly category_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly feed_sources: ReadonlyArray<{
        readonly content_source_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneFeedMutationVariables = Exact<{
  object: FeedsInsertInput;
  on_conflict?: InputMaybe<FeedsOnConflict>;
}>;

export type CreateOneFeedMutationQuery = {
  readonly insert_feeds_one?: {
    readonly created_at: string;
    readonly id: string;
    readonly name?: string | null;
    readonly user_id?: string | null;
    readonly feed_categories: ReadonlyArray<{
      readonly category_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly feed_sources: ReadonlyArray<{
      readonly content_source_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type CreateManyFollowMutationVariables = Exact<{
  objects: ReadonlyArray<FollowsInsertInput> | FollowsInsertInput;
  on_conflict?: InputMaybe<FollowsOnConflict>;
}>;

export type CreateManyFollowMutationQuery = {
  readonly insert_follows?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly followed_entity: any;
      readonly followed_id: string;
      readonly id: string;
      readonly user_id: string;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneFollowMutationVariables = Exact<{
  object: FollowsInsertInput;
  on_conflict?: InputMaybe<FollowsOnConflict>;
}>;

export type CreateOneFollowMutationQuery = {
  readonly insert_follows_one?: {
    readonly created_at?: string | null;
    readonly followed_entity: any;
    readonly followed_id: string;
    readonly id: string;
    readonly user_id: string;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type CreateManyMetricDefinitionMutationVariables = Exact<{
  objects:
    | ReadonlyArray<MetricDefinitionsInsertInput>
    | MetricDefinitionsInsertInput;
  on_conflict?: InputMaybe<MetricDefinitionsOnConflict>;
}>;

export type CreateManyMetricDefinitionMutationQuery = {
  readonly insert_metric_definitions?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category?: string | null;
      readonly description?: string | null;
      readonly id: number;
      readonly is_dimensional?: boolean | null;
      readonly name: string;
      readonly type: string;
      readonly unit?: string | null;
      readonly company_metrics: ReadonlyArray<{
        readonly company_id: string;
        readonly crawl_id: string;
        readonly id: number;
        readonly metric_id?: number | null;
        readonly timestamp: string;
        readonly value: Record<string, any>;
      }>;
      readonly spider_metrics: ReadonlyArray<{
        readonly crawl_id: string;
        readonly id: number;
        readonly metric_id?: number | null;
        readonly timestamp: string;
        readonly value: Record<string, any>;
      }>;
    }>;
  } | null;
};

export type CreateOneMetricDefinitionMutationVariables = Exact<{
  object: MetricDefinitionsInsertInput;
  on_conflict?: InputMaybe<MetricDefinitionsOnConflict>;
}>;

export type CreateOneMetricDefinitionMutationQuery = {
  readonly insert_metric_definitions_one?: {
    readonly category?: string | null;
    readonly description?: string | null;
    readonly id: number;
    readonly is_dimensional?: boolean | null;
    readonly name: string;
    readonly type: string;
    readonly unit?: string | null;
    readonly company_metrics: ReadonlyArray<{
      readonly company_id: string;
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
    }>;
    readonly spider_metrics: ReadonlyArray<{
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
    }>;
  } | null;
};

export type CreateManyNewsMutationVariables = Exact<{
  objects: ReadonlyArray<NewsInsertInput> | NewsInsertInput;
  on_conflict?: InputMaybe<NewsOnConflict>;
}>;

export type CreateManyNewsMutationQuery = {
  readonly insert_news?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
      readonly category?: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly content_source?: {
        readonly company_id?: string | null;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly expected_count?: any | null;
        readonly failed_count?: any | null;
        readonly has_failed?: boolean | null;
        readonly hash?: number | null;
        readonly id: number;
        readonly priority: any;
        readonly refreshed_at?: string | null;
        readonly rss_urls?: ReadonlyArray<string> | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly news_summaries: ReadonlyArray<{
        readonly complexity_level?: any | null;
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly id: string;
        readonly is_current?: boolean | null;
        readonly news_id: string;
        readonly summary?: string | null;
        readonly updated_at?: string | null;
        readonly version: number;
      }>;
    }>;
  } | null;
};

export type CreateOneNewsMutationVariables = Exact<{
  object: NewsInsertInput;
  on_conflict?: InputMaybe<NewsOnConflict>;
}>;

export type CreateOneNewsMutationQuery = {
  readonly insert_news_one?: {
    readonly author?: string | null;
    readonly body?: string | null;
    readonly category_id?: number | null;
    readonly company_id?: string | null;
    readonly content_source_id?: number | null;
    readonly content_status: any;
    readonly created_at: string;
    readonly description?: string | null;
    readonly failed_count?: any | null;
    readonly featured_image?: string | null;
    readonly has_summary: boolean;
    readonly hash?: number | null;
    readonly id: string;
    readonly keywords?: Record<string, any> | null;
    readonly published_at?: string | null;
    readonly scrape_frequency: any;
    readonly scraped_at?: string | null;
    readonly title?: string | null;
    readonly updated_at: string;
    readonly url: string;
    readonly category?: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly content_source?: {
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly news_summaries: ReadonlyArray<{
      readonly complexity_level?: any | null;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: string;
      readonly is_current?: boolean | null;
      readonly news_id: string;
      readonly summary?: string | null;
      readonly updated_at?: string | null;
      readonly version: number;
    }>;
  } | null;
};

export type CreateManyNewsSummaryMutationVariables = Exact<{
  objects: ReadonlyArray<NewsSummariesInsertInput> | NewsSummariesInsertInput;
  on_conflict?: InputMaybe<NewsSummariesOnConflict>;
}>;

export type CreateManyNewsSummaryMutationQuery = {
  readonly insert_news_summaries?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly complexity_level?: any | null;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: string;
      readonly is_current?: boolean | null;
      readonly news_id: string;
      readonly summary?: string | null;
      readonly updated_at?: string | null;
      readonly version: number;
      readonly news: {
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      };
    }>;
  } | null;
};

export type CreateOneNewsSummaryMutationVariables = Exact<{
  object: NewsSummariesInsertInput;
  on_conflict?: InputMaybe<NewsSummariesOnConflict>;
}>;

export type CreateOneNewsSummaryMutationQuery = {
  readonly insert_news_summaries_one?: {
    readonly complexity_level?: any | null;
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly id: string;
    readonly is_current?: boolean | null;
    readonly news_id: string;
    readonly summary?: string | null;
    readonly updated_at?: string | null;
    readonly version: number;
    readonly news: {
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    };
  } | null;
};

export type CreateManyNewsTagMutationVariables = Exact<{
  objects: ReadonlyArray<NewsTagsInsertInput> | NewsTagsInsertInput;
  on_conflict?: InputMaybe<NewsTagsOnConflict>;
}>;

export type CreateManyNewsTagMutationQuery = {
  readonly insert_news_tags?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly id: number;
      readonly news_id?: string | null;
      readonly tag_id: number;
      readonly tag: {
        readonly body?: string | null;
        readonly created_at?: string | null;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneNewsTagMutationVariables = Exact<{
  object: NewsTagsInsertInput;
  on_conflict?: InputMaybe<NewsTagsOnConflict>;
}>;

export type CreateOneNewsTagMutationQuery = {
  readonly insert_news_tags_one?: {
    readonly id: number;
    readonly news_id?: string | null;
    readonly tag_id: number;
    readonly tag: {
      readonly body?: string | null;
      readonly created_at?: string | null;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    };
  } | null;
};

export type CreateManyNewsletterMutationVariables = Exact<{
  objects: ReadonlyArray<NewslettersInsertInput> | NewslettersInsertInput;
  on_conflict?: InputMaybe<NewslettersOnConflict>;
}>;

export type CreateManyNewsletterMutationQuery = {
  readonly insert_newsletters?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly frequency: string;
      readonly generated_content?: string | null;
      readonly id: string;
      readonly start_date: string;
      readonly title: string;
      readonly updated_at?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null;
};

export type CreateOneNewsletterMutationVariables = Exact<{
  object: NewslettersInsertInput;
  on_conflict?: InputMaybe<NewslettersOnConflict>;
}>;

export type CreateOneNewsletterMutationQuery = {
  readonly insert_newsletters_one?: {
    readonly content_status: any;
    readonly created_at?: string | null;
    readonly end_date: string;
    readonly frequency: string;
    readonly generated_content?: string | null;
    readonly id: string;
    readonly start_date: string;
    readonly title: string;
    readonly updated_at?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type CreateManyPaymentProviderMutationVariables = Exact<{
  objects:
    | ReadonlyArray<PaymentProvidersInsertInput>
    | PaymentProvidersInsertInput;
  on_conflict?: InputMaybe<PaymentProvidersOnConflict>;
}>;

export type CreateManyPaymentProviderMutationQuery = {
  readonly insert_payment_providers?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_active?: boolean | null;
      readonly name: string;
      readonly updated_at?: string | null;
      readonly customer_payments: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      }>;
      readonly customer_subscriptions: ReadonlyArray<{
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
    }>;
  } | null;
};

export type CreateOnePaymentProviderMutationVariables = Exact<{
  object: PaymentProvidersInsertInput;
  on_conflict?: InputMaybe<PaymentProvidersOnConflict>;
}>;

export type CreateOnePaymentProviderMutationQuery = {
  readonly insert_payment_providers_one?: {
    readonly created_at?: string | null;
    readonly id: number;
    readonly is_active?: boolean | null;
    readonly name: string;
    readonly updated_at?: string | null;
    readonly customer_payments: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
    readonly customer_subscriptions: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  } | null;
};

export type CreateManyPlanPermissionMutationVariables = Exact<{
  objects:
    | ReadonlyArray<PlanPermissionsInsertInput>
    | PlanPermissionsInsertInput;
  on_conflict?: InputMaybe<PlanPermissionsOnConflict>;
}>;

export type CreateManyPlanPermissionMutationQuery = {
  readonly insert_plan_permissions?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly feature: string;
      readonly id: number;
      readonly plan: any;
    }>;
  } | null;
};

export type CreateOnePlanPermissionMutationVariables = Exact<{
  object: PlanPermissionsInsertInput;
  on_conflict?: InputMaybe<PlanPermissionsOnConflict>;
}>;

export type CreateOnePlanPermissionMutationQuery = {
  readonly insert_plan_permissions_one?: {
    readonly feature: string;
    readonly id: number;
    readonly plan: any;
  } | null;
};

export type CreateManyRecentErrorMutationVariables = Exact<{
  objects: ReadonlyArray<RecentErrorsInsertInput> | RecentErrorsInsertInput;
}>;

export type CreateManyRecentErrorMutationQuery = {
  readonly insert_recent_errors?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly error_type?: any | null;
      readonly message?: string | null;
      readonly metadata?: Record<string, any> | null;
      readonly service_name?: string | null;
      readonly severity?: any | null;
    }>;
  } | null;
};

export type CreateOneRecentErrorMutationVariables = Exact<{
  object: RecentErrorsInsertInput;
}>;

export type CreateOneRecentErrorMutationQuery = {
  readonly insert_recent_errors_one?: {
    readonly created_at?: string | null;
    readonly error_type?: any | null;
    readonly message?: string | null;
    readonly metadata?: Record<string, any> | null;
    readonly service_name?: string | null;
    readonly severity?: any | null;
  } | null;
};

export type CreateManyReferralMutationVariables = Exact<{
  objects: ReadonlyArray<ReferralsInsertInput> | ReferralsInsertInput;
  on_conflict?: InputMaybe<ReferralsOnConflict>;
}>;

export type CreateManyReferralMutationQuery = {
  readonly insert_referrals?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly browser?: string | null;
      readonly client_fingerprint?: string | null;
      readonly conversion_value?: number | null;
      readonly converted_at?: string | null;
      readonly country_code?: string | null;
      readonly created_at?: string | null;
      readonly device_type?: string | null;
      readonly id: string;
      readonly ip_address?: any | null;
      readonly is_suspicious?: boolean | null;
      readonly landing_page?: string | null;
      readonly last_failed_attempt?: string | null;
      readonly referral_status?: any | null;
      readonly referrer_code: string;
      readonly region?: string | null;
      readonly security_flags?: Record<string, any> | null;
      readonly user_agent?: string | null;
      readonly utm_campaign?: string | null;
      readonly utm_medium?: string | null;
      readonly utm_source?: string | null;
      readonly validation_attempts?: number | null;
      readonly visitor_id: string;
    }>;
  } | null;
};

export type CreateOneReferralMutationVariables = Exact<{
  object: ReferralsInsertInput;
  on_conflict?: InputMaybe<ReferralsOnConflict>;
}>;

export type CreateOneReferralMutationQuery = {
  readonly insert_referrals_one?: {
    readonly browser?: string | null;
    readonly client_fingerprint?: string | null;
    readonly conversion_value?: number | null;
    readonly converted_at?: string | null;
    readonly country_code?: string | null;
    readonly created_at?: string | null;
    readonly device_type?: string | null;
    readonly id: string;
    readonly ip_address?: any | null;
    readonly is_suspicious?: boolean | null;
    readonly landing_page?: string | null;
    readonly last_failed_attempt?: string | null;
    readonly referral_status?: any | null;
    readonly referrer_code: string;
    readonly region?: string | null;
    readonly security_flags?: Record<string, any> | null;
    readonly user_agent?: string | null;
    readonly utm_campaign?: string | null;
    readonly utm_medium?: string | null;
    readonly utm_source?: string | null;
    readonly validation_attempts?: number | null;
    readonly visitor_id: string;
  } | null;
};

export type CreateManyReferrerBlockMutationVariables = Exact<{
  objects: ReadonlyArray<ReferrerBlocksInsertInput> | ReferrerBlocksInsertInput;
  on_conflict?: InputMaybe<ReferrerBlocksOnConflict>;
}>;

export type CreateManyReferrerBlockMutationQuery = {
  readonly insert_referrer_blocks?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly blocked_at?: string | null;
      readonly blocked_by: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_permanent?: boolean | null;
      readonly reason?: string | null;
      readonly referrer_code: string;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type CreateOneReferrerBlockMutationVariables = Exact<{
  object: ReferrerBlocksInsertInput;
  on_conflict?: InputMaybe<ReferrerBlocksOnConflict>;
}>;

export type CreateOneReferrerBlockMutationQuery = {
  readonly insert_referrer_blocks_one?: {
    readonly blocked_at?: string | null;
    readonly blocked_by: string;
    readonly created_at?: string | null;
    readonly id: string;
    readonly is_permanent?: boolean | null;
    readonly reason?: string | null;
    readonly referrer_code: string;
    readonly updated_at?: string | null;
  } | null;
};

export type CreateManyResearchMutationVariables = Exact<{
  objects: ReadonlyArray<ResearchInsertInput> | ResearchInsertInput;
  on_conflict?: InputMaybe<ResearchOnConflict>;
}>;

export type CreateManyResearchMutationQuery = {
  readonly insert_research?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly research_embedding?: {
        readonly chunk: string;
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly embedding_review_id?: number | null;
        readonly id: number;
        readonly is_flagged?: boolean | null;
        readonly research_id: string;
        readonly updated_at: string;
        readonly url?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateManyResearchEmbeddingMutationVariables = Exact<{
  objects:
    | ReadonlyArray<ResearchEmbeddingsInsertInput>
    | ResearchEmbeddingsInsertInput;
  on_conflict?: InputMaybe<ResearchEmbeddingsOnConflict>;
}>;

export type CreateManyResearchEmbeddingMutationQuery = {
  readonly insert_research_embeddings?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly chunk: string;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly embedding_review_id?: number | null;
      readonly id: number;
      readonly is_flagged?: boolean | null;
      readonly research_id: string;
      readonly updated_at: string;
      readonly url?: string | null;
      readonly embedding_review?: {
        readonly agent_review?: boolean | null;
        readonly created_at: string;
        readonly human_review?: boolean | null;
        readonly id: number;
        readonly notes?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly research: {
        readonly abstract?: string | null;
        readonly abstract_url: string;
        readonly affiliations?: Record<string, any> | null;
        readonly authors?: Record<string, any> | null;
        readonly category?: string | null;
        readonly comments?: string | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly doi_url?: string | null;
        readonly figure_count?: any | null;
        readonly has_embedding?: boolean | null;
        readonly id: string;
        readonly is_flagged: boolean;
        readonly keywords?: string | null;
        readonly month?: string | null;
        readonly page_count?: any | null;
        readonly pdf_url?: string | null;
        readonly published_at?: string | null;
        readonly published_in?: string | null;
        readonly summary?: string | null;
        readonly table_count?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly version?: any | null;
        readonly year?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneResearchEmbeddingMutationVariables = Exact<{
  object: ResearchEmbeddingsInsertInput;
  on_conflict?: InputMaybe<ResearchEmbeddingsOnConflict>;
}>;

export type CreateOneResearchEmbeddingMutationQuery = {
  readonly insert_research_embeddings_one?: {
    readonly chunk: string;
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly embedding_review_id?: number | null;
    readonly id: number;
    readonly is_flagged?: boolean | null;
    readonly research_id: string;
    readonly updated_at: string;
    readonly url?: string | null;
    readonly embedding_review?: {
      readonly agent_review?: boolean | null;
      readonly created_at: string;
      readonly human_review?: boolean | null;
      readonly id: number;
      readonly notes?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly research: {
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
    };
  } | null;
};

export type CreateOneResearchMutationVariables = Exact<{
  object: ResearchInsertInput;
  on_conflict?: InputMaybe<ResearchOnConflict>;
}>;

export type CreateOneResearchMutationQuery = {
  readonly insert_research_one?: {
    readonly abstract?: string | null;
    readonly abstract_url: string;
    readonly affiliations?: Record<string, any> | null;
    readonly authors?: Record<string, any> | null;
    readonly category?: string | null;
    readonly comments?: string | null;
    readonly content_status: any;
    readonly created_at: string;
    readonly doi_url?: string | null;
    readonly figure_count?: any | null;
    readonly has_embedding?: boolean | null;
    readonly id: string;
    readonly is_flagged: boolean;
    readonly keywords?: string | null;
    readonly month?: string | null;
    readonly page_count?: any | null;
    readonly pdf_url?: string | null;
    readonly published_at?: string | null;
    readonly published_in?: string | null;
    readonly summary?: string | null;
    readonly table_count?: any | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly version?: any | null;
    readonly year?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly research_embedding?: {
      readonly chunk: string;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly embedding_review_id?: number | null;
      readonly id: number;
      readonly is_flagged?: boolean | null;
      readonly research_id: string;
      readonly updated_at: string;
      readonly url?: string | null;
    } | null;
  } | null;
};

export type CreateManyResponseMutationVariables = Exact<{
  objects: ReadonlyArray<ResponsesInsertInput> | ResponsesInsertInput;
  on_conflict?: InputMaybe<ResponsesOnConflict>;
}>;

export type CreateManyResponseMutationQuery = {
  readonly insert_responses?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly downvotes?: number | null;
      readonly id: number;
      readonly output: string;
      readonly search_id: number;
      readonly upvotes?: number | null;
      readonly search: {
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly id: number;
        readonly input: string;
        readonly tokens_used?: any | null;
        readonly user_ids?: ReadonlyArray<string> | null;
      };
    }>;
  } | null;
};

export type CreateOneResponseMutationVariables = Exact<{
  object: ResponsesInsertInput;
  on_conflict?: InputMaybe<ResponsesOnConflict>;
}>;

export type CreateOneResponseMutationQuery = {
  readonly insert_responses_one?: {
    readonly created_at?: string | null;
    readonly downvotes?: number | null;
    readonly id: number;
    readonly output: string;
    readonly search_id: number;
    readonly upvotes?: number | null;
    readonly search: {
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: number;
      readonly input: string;
      readonly tokens_used?: any | null;
      readonly user_ids?: ReadonlyArray<string> | null;
    };
  } | null;
};

export type CreateManyRoleHierarchyMutationVariables = Exact<{
  objects: ReadonlyArray<RoleHierarchyInsertInput> | RoleHierarchyInsertInput;
  on_conflict?: InputMaybe<RoleHierarchyOnConflict>;
}>;

export type CreateManyRoleHierarchyMutationQuery = {
  readonly insert_role_hierarchy?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly child_role: any;
      readonly parent_role: any;
    }>;
  } | null;
};

export type CreateOneRoleHierarchyMutationVariables = Exact<{
  object: RoleHierarchyInsertInput;
  on_conflict?: InputMaybe<RoleHierarchyOnConflict>;
}>;

export type CreateOneRoleHierarchyMutationQuery = {
  readonly insert_role_hierarchy_one?: {
    readonly child_role: any;
    readonly parent_role: any;
  } | null;
};

export type CreateManyRolePermissionMutationVariables = Exact<{
  objects:
    | ReadonlyArray<RolePermissionsInsertInput>
    | RolePermissionsInsertInput;
  on_conflict?: InputMaybe<RolePermissionsOnConflict>;
}>;

export type CreateManyRolePermissionMutationQuery = {
  readonly insert_role_permissions?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly cached_permissions?: Record<string, any> | null;
      readonly conditions?: Record<string, any> | null;
      readonly id: number;
      readonly inherit_from?: ReadonlyArray<any> | null;
      readonly last_updated?: string | null;
      readonly permissions?: Record<string, any> | null;
      readonly role: any;
      readonly table_name: string;
    }>;
  } | null;
};

export type CreateManyRolePermissionsMaterializedMutationVariables = Exact<{
  objects:
    | ReadonlyArray<RolePermissionsMaterializedInsertInput>
    | RolePermissionsMaterializedInsertInput;
  on_conflict?: InputMaybe<RolePermissionsMaterializedOnConflict>;
}>;

export type CreateManyRolePermissionsMaterializedMutationQuery = {
  readonly insert_role_permissions_materialized?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly last_updated?: string | null;
      readonly permissions: Record<string, any>;
      readonly role: any;
    }>;
  } | null;
};

export type CreateOneRolePermissionsMaterializedMutationVariables = Exact<{
  object: RolePermissionsMaterializedInsertInput;
  on_conflict?: InputMaybe<RolePermissionsMaterializedOnConflict>;
}>;

export type CreateOneRolePermissionsMaterializedMutationQuery = {
  readonly insert_role_permissions_materialized_one?: {
    readonly last_updated?: string | null;
    readonly permissions: Record<string, any>;
    readonly role: any;
  } | null;
};

export type CreateOneRolePermissionMutationVariables = Exact<{
  object: RolePermissionsInsertInput;
  on_conflict?: InputMaybe<RolePermissionsOnConflict>;
}>;

export type CreateOneRolePermissionMutationQuery = {
  readonly insert_role_permissions_one?: {
    readonly cached_permissions?: Record<string, any> | null;
    readonly conditions?: Record<string, any> | null;
    readonly id: number;
    readonly inherit_from?: ReadonlyArray<any> | null;
    readonly last_updated?: string | null;
    readonly permissions?: Record<string, any> | null;
    readonly role: any;
    readonly table_name: string;
  } | null;
};

export type CreateManyScoringWeightMutationVariables = Exact<{
  objects: ReadonlyArray<ScoringWeightsInsertInput> | ScoringWeightsInsertInput;
  on_conflict?: InputMaybe<ScoringWeightsOnConflict>;
}>;

export type CreateManyScoringWeightMutationQuery = {
  readonly insert_scoring_weights?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly description?: string | null;
      readonly id: string;
      readonly name: string;
      readonly updated_at?: string | null;
      readonly weight: any;
    }>;
  } | null;
};

export type CreateOneScoringWeightMutationVariables = Exact<{
  object: ScoringWeightsInsertInput;
  on_conflict?: InputMaybe<ScoringWeightsOnConflict>;
}>;

export type CreateOneScoringWeightMutationQuery = {
  readonly insert_scoring_weights_one?: {
    readonly description?: string | null;
    readonly id: string;
    readonly name: string;
    readonly updated_at?: string | null;
    readonly weight: any;
  } | null;
};

export type CreateManySearchMutationVariables = Exact<{
  objects: ReadonlyArray<SearchesInsertInput> | SearchesInsertInput;
  on_conflict?: InputMaybe<SearchesOnConflict>;
}>;

export type CreateManySearchMutationQuery = {
  readonly insert_searches?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: number;
      readonly input: string;
      readonly tokens_used?: any | null;
      readonly user_ids?: ReadonlyArray<string> | null;
      readonly responses: ReadonlyArray<{
        readonly created_at?: string | null;
        readonly downvotes?: number | null;
        readonly id: number;
        readonly output: string;
        readonly search_id: number;
        readonly upvotes?: number | null;
      }>;
    }>;
  } | null;
};

export type CreateOneSearchMutationVariables = Exact<{
  object: SearchesInsertInput;
  on_conflict?: InputMaybe<SearchesOnConflict>;
}>;

export type CreateOneSearchMutationQuery = {
  readonly insert_searches_one?: {
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly id: number;
    readonly input: string;
    readonly tokens_used?: any | null;
    readonly user_ids?: ReadonlyArray<string> | null;
    readonly responses: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly downvotes?: number | null;
      readonly id: number;
      readonly output: string;
      readonly search_id: number;
      readonly upvotes?: number | null;
    }>;
  } | null;
};

export type CreateManySocialMediaMutationVariables = Exact<{
  objects: ReadonlyArray<SocialMediaInsertInput> | SocialMediaInsertInput;
  on_conflict?: InputMaybe<SocialMediaOnConflict>;
}>;

export type CreateManySocialMediaMutationQuery = {
  readonly insert_social_media?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly facebook_url?: string | null;
      readonly id: number;
      readonly instagram_url?: string | null;
      readonly linkedin_url?: string | null;
      readonly twitter_url?: string | null;
      readonly updated_at?: string | null;
      readonly youtube_url?: string | null;
      readonly companies: ReadonlyArray<{
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
    }>;
  } | null;
};

export type CreateOneSocialMediaMutationVariables = Exact<{
  object: SocialMediaInsertInput;
  on_conflict?: InputMaybe<SocialMediaOnConflict>;
}>;

export type CreateOneSocialMediaMutationQuery = {
  readonly insert_social_media_one?: {
    readonly created_at?: string | null;
    readonly facebook_url?: string | null;
    readonly id: number;
    readonly instagram_url?: string | null;
    readonly linkedin_url?: string | null;
    readonly twitter_url?: string | null;
    readonly updated_at?: string | null;
    readonly youtube_url?: string | null;
    readonly companies: ReadonlyArray<{
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
  } | null;
};

export type CreateManySpiderMetricMutationVariables = Exact<{
  objects: ReadonlyArray<SpiderMetricsInsertInput> | SpiderMetricsInsertInput;
  on_conflict?: InputMaybe<SpiderMetricsOnConflict>;
}>;

export type CreateManySpiderMetricMutationQuery = {
  readonly insert_spider_metrics?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
      readonly metric_definition?: {
        readonly category?: string | null;
        readonly description?: string | null;
        readonly id: number;
        readonly is_dimensional?: boolean | null;
        readonly name: string;
        readonly type: string;
        readonly unit?: string | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneSpiderMetricMutationVariables = Exact<{
  object: SpiderMetricsInsertInput;
  on_conflict?: InputMaybe<SpiderMetricsOnConflict>;
}>;

export type CreateOneSpiderMetricMutationQuery = {
  readonly insert_spider_metrics_one?: {
    readonly crawl_id: string;
    readonly id: number;
    readonly metric_id?: number | null;
    readonly timestamp: string;
    readonly value: Record<string, any>;
    readonly metric_definition?: {
      readonly category?: string | null;
      readonly description?: string | null;
      readonly id: number;
      readonly is_dimensional?: boolean | null;
      readonly name: string;
      readonly type: string;
      readonly unit?: string | null;
    } | null;
  } | null;
};

export type CreateManyStrapiMigrationMutationVariables = Exact<{
  objects:
    | ReadonlyArray<StrapiMigrationsInsertInput>
    | StrapiMigrationsInsertInput;
  on_conflict?: InputMaybe<StrapiMigrationsOnConflict>;
}>;

export type CreateManyStrapiMigrationMutationQuery = {
  readonly insert_strapi_migrations?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly id: number;
      readonly name?: string | null;
      readonly time?: string | null;
    }>;
  } | null;
};

export type CreateManyStrapiMigrationsInternalMutationVariables = Exact<{
  objects:
    | ReadonlyArray<StrapiMigrationsInternalInsertInput>
    | StrapiMigrationsInternalInsertInput;
  on_conflict?: InputMaybe<StrapiMigrationsInternalOnConflict>;
}>;

export type CreateManyStrapiMigrationsInternalMutationQuery = {
  readonly insert_strapi_migrations_internal?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly id: number;
      readonly name?: string | null;
      readonly time?: string | null;
    }>;
  } | null;
};

export type CreateOneStrapiMigrationsInternalMutationVariables = Exact<{
  object: StrapiMigrationsInternalInsertInput;
  on_conflict?: InputMaybe<StrapiMigrationsInternalOnConflict>;
}>;

export type CreateOneStrapiMigrationsInternalMutationQuery = {
  readonly insert_strapi_migrations_internal_one?: {
    readonly id: number;
    readonly name?: string | null;
    readonly time?: string | null;
  } | null;
};

export type CreateOneStrapiMigrationMutationVariables = Exact<{
  object: StrapiMigrationsInsertInput;
  on_conflict?: InputMaybe<StrapiMigrationsOnConflict>;
}>;

export type CreateOneStrapiMigrationMutationQuery = {
  readonly insert_strapi_migrations_one?: {
    readonly id: number;
    readonly name?: string | null;
    readonly time?: string | null;
  } | null;
};

export type CreateManyTableMaintenanceLogMutationVariables = Exact<{
  objects:
    | ReadonlyArray<TableMaintenanceLogInsertInput>
    | TableMaintenanceLogInsertInput;
  on_conflict?: InputMaybe<TableMaintenanceLogOnConflict>;
}>;

export type CreateManyTableMaintenanceLogMutationQuery = {
  readonly insert_table_maintenance_log?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly detail?: string | null;
      readonly id: number;
      readonly logged_at?: string | null;
      readonly operation?: string | null;
    }>;
  } | null;
};

export type CreateOneTableMaintenanceLogMutationVariables = Exact<{
  object: TableMaintenanceLogInsertInput;
  on_conflict?: InputMaybe<TableMaintenanceLogOnConflict>;
}>;

export type CreateOneTableMaintenanceLogMutationQuery = {
  readonly insert_table_maintenance_log_one?: {
    readonly detail?: string | null;
    readonly id: number;
    readonly logged_at?: string | null;
    readonly operation?: string | null;
  } | null;
};

export type CreateManyTableQueryPerformanceMutationVariables = Exact<{
  objects:
    | ReadonlyArray<TableQueryPerformanceInsertInput>
    | TableQueryPerformanceInsertInput;
  on_conflict?: InputMaybe<TableQueryPerformanceOnConflict>;
}>;

export type CreateManyTableQueryPerformanceMutationQuery = {
  readonly insert_table_query_performance?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly avg_duration?: any | null;
      readonly capture_time?: string | null;
      readonly execution_count?: number | null;
      readonly query?: string | null;
    }>;
  } | null;
};

export type CreateOneTableQueryPerformanceMutationVariables = Exact<{
  object: TableQueryPerformanceInsertInput;
  on_conflict?: InputMaybe<TableQueryPerformanceOnConflict>;
}>;

export type CreateOneTableQueryPerformanceMutationQuery = {
  readonly insert_table_query_performance_one?: {
    readonly avg_duration?: any | null;
    readonly capture_time?: string | null;
    readonly execution_count?: number | null;
    readonly query?: string | null;
  } | null;
};

export type CreateManyTableSequenceUsageMutationVariables = Exact<{
  objects:
    | ReadonlyArray<TableSequenceUsageInsertInput>
    | TableSequenceUsageInsertInput;
  on_conflict?: InputMaybe<TableSequenceUsageOnConflict>;
}>;

export type CreateManyTableSequenceUsageMutationQuery = {
  readonly insert_table_sequence_usage?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly capture_time?: string | null;
      readonly current_value?: number | null;
      readonly max_value?: number | null;
      readonly sequence_name?: string | null;
    }>;
  } | null;
};

export type CreateOneTableSequenceUsageMutationVariables = Exact<{
  object: TableSequenceUsageInsertInput;
  on_conflict?: InputMaybe<TableSequenceUsageOnConflict>;
}>;

export type CreateOneTableSequenceUsageMutationQuery = {
  readonly insert_table_sequence_usage_one?: {
    readonly capture_time?: string | null;
    readonly current_value?: number | null;
    readonly max_value?: number | null;
    readonly sequence_name?: string | null;
  } | null;
};

export type CreateManyTableStatisticMutationVariables = Exact<{
  objects:
    | ReadonlyArray<TableStatisticsInsertInput>
    | TableStatisticsInsertInput;
  on_conflict?: InputMaybe<TableStatisticsOnConflict>;
}>;

export type CreateManyTableStatisticMutationQuery = {
  readonly insert_table_statistics?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly buffer_cache_hit_ratio?: any | null;
      readonly capture_time: string;
      readonly dead_tuples?: number | null;
      readonly estimated_bloat_ratio?: any | null;
      readonly index_scan_count?: number | null;
      readonly index_size?: number | null;
      readonly index_usage?: Record<string, any> | null;
      readonly last_analyze?: string | null;
      readonly last_vacuum?: string | null;
      readonly live_tuples?: number | null;
      readonly row_count?: number | null;
      readonly seq_scan_count?: number | null;
      readonly table_name: string;
      readonly table_size?: number | null;
    }>;
  } | null;
};

export type CreateOneTableStatisticMutationVariables = Exact<{
  object: TableStatisticsInsertInput;
  on_conflict?: InputMaybe<TableStatisticsOnConflict>;
}>;

export type CreateOneTableStatisticMutationQuery = {
  readonly insert_table_statistics_one?: {
    readonly buffer_cache_hit_ratio?: any | null;
    readonly capture_time: string;
    readonly dead_tuples?: number | null;
    readonly estimated_bloat_ratio?: any | null;
    readonly index_scan_count?: number | null;
    readonly index_size?: number | null;
    readonly index_usage?: Record<string, any> | null;
    readonly last_analyze?: string | null;
    readonly last_vacuum?: string | null;
    readonly live_tuples?: number | null;
    readonly row_count?: number | null;
    readonly seq_scan_count?: number | null;
    readonly table_name: string;
    readonly table_size?: number | null;
  } | null;
};

export type CreateManyTagMutationVariables = Exact<{
  objects: ReadonlyArray<TagsInsertInput> | TagsInsertInput;
  on_conflict?: InputMaybe<TagsOnConflict>;
}>;

export type CreateManyTagMutationQuery = {
  readonly insert_tags?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly body?: string | null;
      readonly created_at?: string | null;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
      readonly content_tags: ReadonlyArray<{
        readonly content_id: string;
        readonly tag_id: number;
      }>;
      readonly news_tags: ReadonlyArray<{
        readonly id: number;
        readonly news_id?: string | null;
        readonly tag_id: number;
      }>;
    }>;
  } | null;
};

export type CreateOneTagMutationVariables = Exact<{
  object: TagsInsertInput;
  on_conflict?: InputMaybe<TagsOnConflict>;
}>;

export type CreateOneTagMutationQuery = {
  readonly insert_tags_one?: {
    readonly body?: string | null;
    readonly created_at?: string | null;
    readonly document_id?: string | null;
    readonly id: number;
    readonly locale?: string | null;
    readonly name: string;
    readonly published_at?: string | null;
    readonly updated_at?: string | null;
    readonly content_tags: ReadonlyArray<{
      readonly content_id: string;
      readonly tag_id: number;
    }>;
    readonly news_tags: ReadonlyArray<{
      readonly id: number;
      readonly news_id?: string | null;
      readonly tag_id: number;
    }>;
  } | null;
};

export type CreateManyUserMetricMutationVariables = Exact<{
  objects: ReadonlyArray<UserMetricsInsertInput> | UserMetricsInsertInput;
  on_conflict?: InputMaybe<UserMetricsOnConflict>;
}>;

export type CreateManyUserMetricMutationQuery = {
  readonly insert_user_metrics?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly achievements?: Record<string, any> | null;
      readonly best_streak?: number | null;
      readonly created_at?: string | null;
      readonly current_level?: number | null;
      readonly current_streak?: number | null;
      readonly current_xp?: number | null;
      readonly downvote_count?: number | null;
      readonly id: string;
      readonly interaction_stats?: Record<string, any> | null;
      readonly last_vote_date?: string | null;
      readonly multipliers?: Record<string, any> | null;
      readonly points?: number | null;
      readonly points_breakdown?: Record<string, any> | null;
      readonly titles?: Record<string, any> | null;
      readonly today_vote_count?: number | null;
      readonly total_reading_time?: number | null;
      readonly total_votes?: number | null;
      readonly updated_at?: string | null;
      readonly upvote_count?: number | null;
      readonly user_id: string;
      readonly vote_accuracy?: number | null;
      readonly xp_to_next_level?: number | null;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type CreateOneUserMetricMutationVariables = Exact<{
  object: UserMetricsInsertInput;
  on_conflict?: InputMaybe<UserMetricsOnConflict>;
}>;

export type CreateOneUserMetricMutationQuery = {
  readonly insert_user_metrics_one?: {
    readonly achievements?: Record<string, any> | null;
    readonly best_streak?: number | null;
    readonly created_at?: string | null;
    readonly current_level?: number | null;
    readonly current_streak?: number | null;
    readonly current_xp?: number | null;
    readonly downvote_count?: number | null;
    readonly id: string;
    readonly interaction_stats?: Record<string, any> | null;
    readonly last_vote_date?: string | null;
    readonly multipliers?: Record<string, any> | null;
    readonly points?: number | null;
    readonly points_breakdown?: Record<string, any> | null;
    readonly titles?: Record<string, any> | null;
    readonly today_vote_count?: number | null;
    readonly total_reading_time?: number | null;
    readonly total_votes?: number | null;
    readonly updated_at?: string | null;
    readonly upvote_count?: number | null;
    readonly user_id: string;
    readonly vote_accuracy?: number | null;
    readonly xp_to_next_level?: number | null;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type CreateManyUserProfileMutationVariables = Exact<{
  objects: ReadonlyArray<UserProfilesInsertInput> | UserProfilesInsertInput;
  on_conflict?: InputMaybe<UserProfilesOnConflict>;
}>;

export type CreateManyUserProfileMutationQuery = {
  readonly insert_user_profiles?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly comments: ReadonlyArray<{
        readonly content: string;
        readonly content_id: string;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly id: string;
        readonly parent_comment_id?: string | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly company_employees: ReadonlyArray<{
        readonly access_level: any;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date?: string | null;
        readonly id: string;
        readonly job_description?: string | null;
        readonly role: string;
        readonly start_date?: string | null;
        readonly status?: boolean | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_type?: any | null;
        readonly created_at?: string | null;
        readonly email?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly phone?: string | null;
        readonly privacy_level?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly content_source_visits: ReadonlyArray<{
        readonly content_id: string;
        readonly created_at?: string | null;
        readonly id: string;
        readonly user_id?: string | null;
      }>;
      readonly customer_payments: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      }>;
      readonly customer_subscriptions: ReadonlyArray<{
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly feedbacks: ReadonlyArray<{
        readonly created_at: string;
        readonly device_info?: string | null;
        readonly feedback_status?: any | null;
        readonly feedback_type?: any | null;
        readonly id: number;
        readonly message: string;
        readonly page_identifier: string;
        readonly rating?: number | null;
        readonly resolution_comment?: string | null;
        readonly updated_at: string;
        readonly user_id?: string | null;
      }>;
      readonly feeds: ReadonlyArray<{
        readonly created_at: string;
        readonly id: string;
        readonly name?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly follows: ReadonlyArray<{
        readonly created_at?: string | null;
        readonly followed_entity: any;
        readonly followed_id: string;
        readonly id: string;
        readonly user_id: string;
      }>;
      readonly user_metric?: {
        readonly achievements?: Record<string, any> | null;
        readonly best_streak?: number | null;
        readonly created_at?: string | null;
        readonly current_level?: number | null;
        readonly current_streak?: number | null;
        readonly current_xp?: number | null;
        readonly downvote_count?: number | null;
        readonly id: string;
        readonly interaction_stats?: Record<string, any> | null;
        readonly last_vote_date?: string | null;
        readonly multipliers?: Record<string, any> | null;
        readonly points?: number | null;
        readonly points_breakdown?: Record<string, any> | null;
        readonly titles?: Record<string, any> | null;
        readonly today_vote_count?: number | null;
        readonly total_reading_time?: number | null;
        readonly total_votes?: number | null;
        readonly updated_at?: string | null;
        readonly upvote_count?: number | null;
        readonly user_id: string;
        readonly vote_accuracy?: number | null;
        readonly xp_to_next_level?: number | null;
      } | null;
    }>;
  } | null;
};

export type CreateOneUserProfileMutationVariables = Exact<{
  object: UserProfilesInsertInput;
  on_conflict?: InputMaybe<UserProfilesOnConflict>;
}>;

export type CreateOneUserProfileMutationQuery = {
  readonly insert_user_profiles_one?: {
    readonly avatar?: string | null;
    readonly created_at?: string | null;
    readonly dob?: any | null;
    readonly email: string;
    readonly followed_count?: number | null;
    readonly followers_count?: number | null;
    readonly gender_id?: any | null;
    readonly given_name?: string | null;
    readonly id: string;
    readonly introduction?: string | null;
    readonly is_active?: boolean | null;
    readonly last_seen?: string | null;
    readonly plan?: any | null;
    readonly role: any;
    readonly surname?: string | null;
    readonly updated_at?: string | null;
    readonly username?: string | null;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly comments: ReadonlyArray<{
      readonly content: string;
      readonly content_id: string;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly parent_comment_id?: string | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly company_employees: ReadonlyArray<{
      readonly access_level: any;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date?: string | null;
      readonly id: string;
      readonly job_description?: string | null;
      readonly role: string;
      readonly start_date?: string | null;
      readonly status?: boolean | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly content_source_visits: ReadonlyArray<{
      readonly content_id: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id?: string | null;
    }>;
    readonly customer_payments: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
    readonly customer_subscriptions: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly feedbacks: ReadonlyArray<{
      readonly created_at: string;
      readonly device_info?: string | null;
      readonly feedback_status?: any | null;
      readonly feedback_type?: any | null;
      readonly id: number;
      readonly message: string;
      readonly page_identifier: string;
      readonly rating?: number | null;
      readonly resolution_comment?: string | null;
      readonly updated_at: string;
      readonly user_id?: string | null;
    }>;
    readonly feeds: ReadonlyArray<{
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly follows: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly followed_entity: any;
      readonly followed_id: string;
      readonly id: string;
      readonly user_id: string;
    }>;
    readonly user_metric?: {
      readonly achievements?: Record<string, any> | null;
      readonly best_streak?: number | null;
      readonly created_at?: string | null;
      readonly current_level?: number | null;
      readonly current_streak?: number | null;
      readonly current_xp?: number | null;
      readonly downvote_count?: number | null;
      readonly id: string;
      readonly interaction_stats?: Record<string, any> | null;
      readonly last_vote_date?: string | null;
      readonly multipliers?: Record<string, any> | null;
      readonly points?: number | null;
      readonly points_breakdown?: Record<string, any> | null;
      readonly titles?: Record<string, any> | null;
      readonly today_vote_count?: number | null;
      readonly total_reading_time?: number | null;
      readonly total_votes?: number | null;
      readonly updated_at?: string | null;
      readonly upvote_count?: number | null;
      readonly user_id: string;
      readonly vote_accuracy?: number | null;
      readonly xp_to_next_level?: number | null;
    } | null;
  } | null;
};

export type CreateManyVoteMutationVariables = Exact<{
  objects: ReadonlyArray<VotesInsertInput> | VotesInsertInput;
  on_conflict?: InputMaybe<VotesOnConflict>;
}>;

export type CreateManyVoteMutationQuery = {
  readonly insert_votes?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id: string;
      readonly vote_type: any;
    }>;
  } | null;
};

export type CreateOneVoteMutationVariables = Exact<{
  object: VotesInsertInput;
  on_conflict?: InputMaybe<VotesOnConflict>;
}>;

export type CreateOneVoteMutationQuery = {
  readonly insert_votes_one?: {
    readonly content_id: string;
    readonly content_type: string;
    readonly created_at?: string | null;
    readonly id: string;
    readonly user_id: string;
    readonly vote_type: any;
  } | null;
};

export type CreateManyWorkflowMutationVariables = Exact<{
  objects: ReadonlyArray<WorkflowsInsertInput> | WorkflowsInsertInput;
  on_conflict?: InputMaybe<WorkflowsOnConflict>;
}>;

export type CreateManyWorkflowMutationQuery = {
  readonly insert_workflows?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly completed_at?: string | null;
      readonly created_at?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly name: string;
      readonly started_at?: string | null;
      readonly status: any;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type CreateOneWorkflowMutationVariables = Exact<{
  object: WorkflowsInsertInput;
  on_conflict?: InputMaybe<WorkflowsOnConflict>;
}>;

export type CreateOneWorkflowMutationQuery = {
  readonly insert_workflows_one?: {
    readonly completed_at?: string | null;
    readonly created_at?: string | null;
    readonly id: string;
    readonly metadata?: Record<string, any> | null;
    readonly name: string;
    readonly started_at?: string | null;
    readonly status: any;
    readonly updated_at?: string | null;
  } | null;
};

export type MatchResearchMutationVariables = Exact<{
  args: MatchResearchArgs;
  distinct_on?: InputMaybe<
    | ReadonlyArray<ResearchEmbeddingsSelectColumn>
    | ResearchEmbeddingsSelectColumn
  >;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
  order_by?: InputMaybe<
    ReadonlyArray<ResearchEmbeddingsOrderBy> | ResearchEmbeddingsOrderBy
  >;
  where?: InputMaybe<ResearchEmbeddingsBoolExp>;
}>;

export type MatchResearchMutationQuery = {
  readonly match_research: ReadonlyArray<{
    readonly chunk: string;
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly embedding_review_id?: number | null;
    readonly id: number;
    readonly is_flagged?: boolean | null;
    readonly research_id: string;
    readonly updated_at: string;
    readonly url?: string | null;
    readonly embedding_review?: {
      readonly agent_review?: boolean | null;
      readonly created_at: string;
      readonly human_review?: boolean | null;
      readonly id: number;
      readonly notes?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly research: {
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
    };
  }>;
};

export type UpdateManyAdDailyMetricMutationVariables = Exact<{
  _inc?: InputMaybe<AdDailyMetricsIncInput>;
  _set?: InputMaybe<AdDailyMetricsSetInput>;
  where: AdDailyMetricsBoolExp;
}>;

export type UpdateManyAdDailyMetricMutationQuery = {
  readonly update_ad_daily_metrics?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly clicks?: number | null;
      readonly created_at?: string | null;
      readonly date: any;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly variant_id?: string | null;
      readonly views?: number | null;
      readonly ad_variant?: {
        readonly active?: boolean | null;
        readonly ad_id: string;
        readonly content: Record<string, any>;
        readonly created_at?: string | null;
        readonly id: string;
        readonly is_control?: boolean | null;
        readonly performance_metrics?: Record<string, any> | null;
        readonly updated_at?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneAdDailyMetricMutationVariables = Exact<{
  _inc?: InputMaybe<AdDailyMetricsIncInput>;
  _set?: InputMaybe<AdDailyMetricsSetInput>;
  pk_columns: AdDailyMetricsPkColumnsInput;
}>;

export type UpdateOneAdDailyMetricMutationQuery = {
  readonly update_ad_daily_metrics_by_pk?: {
    readonly clicks?: number | null;
    readonly created_at?: string | null;
    readonly date: any;
    readonly id: string;
    readonly updated_at?: string | null;
    readonly variant_id?: string | null;
    readonly views?: number | null;
    readonly ad_variant?: {
      readonly active?: boolean | null;
      readonly ad_id: string;
      readonly content: Record<string, any>;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_control?: boolean | null;
      readonly performance_metrics?: Record<string, any> | null;
      readonly updated_at?: string | null;
    } | null;
  } | null;
};

export type UpdateManyAdDailyMetricsManyMutationVariables = Exact<{
  updates: ReadonlyArray<AdDailyMetricsUpdates> | AdDailyMetricsUpdates;
}>;

export type UpdateManyAdDailyMetricsManyMutationQuery = {
  readonly update_ad_daily_metrics_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly clicks?: number | null;
      readonly created_at?: string | null;
      readonly date: any;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly variant_id?: string | null;
      readonly views?: number | null;
      readonly ad_variant?: {
        readonly active?: boolean | null;
        readonly ad_id: string;
        readonly content: Record<string, any>;
        readonly created_at?: string | null;
        readonly id: string;
        readonly is_control?: boolean | null;
        readonly performance_metrics?: Record<string, any> | null;
        readonly updated_at?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyAdPackageMutationVariables = Exact<{
  _inc?: InputMaybe<AdPackagesIncInput>;
  _set?: InputMaybe<AdPackagesSetInput>;
  where: AdPackagesBoolExp;
}>;

export type UpdateManyAdPackageMutationQuery = {
  readonly update_ad_packages?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly avg_roi?: number | null;
      readonly created_at?: string | null;
      readonly description: string;
      readonly expected_ctr?: number | null;
      readonly features: ReadonlyArray<string>;
      readonly id: string;
      readonly name: string;
      readonly position: string;
      readonly price: number;
      readonly updated_at?: string | null;
      readonly view_frequency?: number | null;
      readonly ads: ReadonlyArray<{
        readonly active?: boolean | null;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly id: string;
        readonly package_id?: string | null;
        readonly start_date: string;
        readonly updated_at?: string | null;
      }>;
    }>;
  } | null;
};

export type UpdateOneAdPackageMutationVariables = Exact<{
  _inc?: InputMaybe<AdPackagesIncInput>;
  _set?: InputMaybe<AdPackagesSetInput>;
  pk_columns: AdPackagesPkColumnsInput;
}>;

export type UpdateOneAdPackageMutationQuery = {
  readonly update_ad_packages_by_pk?: {
    readonly active?: boolean | null;
    readonly avg_roi?: number | null;
    readonly created_at?: string | null;
    readonly description: string;
    readonly expected_ctr?: number | null;
    readonly features: ReadonlyArray<string>;
    readonly id: string;
    readonly name: string;
    readonly position: string;
    readonly price: number;
    readonly updated_at?: string | null;
    readonly view_frequency?: number | null;
    readonly ads: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type UpdateManyAdPackagesManyMutationVariables = Exact<{
  updates: ReadonlyArray<AdPackagesUpdates> | AdPackagesUpdates;
}>;

export type UpdateManyAdPackagesManyMutationQuery = {
  readonly update_ad_packages_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly avg_roi?: number | null;
      readonly created_at?: string | null;
      readonly description: string;
      readonly expected_ctr?: number | null;
      readonly features: ReadonlyArray<string>;
      readonly id: string;
      readonly name: string;
      readonly position: string;
      readonly price: number;
      readonly updated_at?: string | null;
      readonly view_frequency?: number | null;
      readonly ads: ReadonlyArray<{
        readonly active?: boolean | null;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly id: string;
        readonly package_id?: string | null;
        readonly start_date: string;
        readonly updated_at?: string | null;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyAdVariantMutationVariables = 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 UpdateManyAdVariantMutationQuery = {
  readonly update_ad_variants?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly ad_id: string;
      readonly content: Record<string, any>;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_control?: boolean | null;
      readonly performance_metrics?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly ad: {
        readonly active?: boolean | null;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly id: string;
        readonly package_id?: string | null;
        readonly start_date: string;
        readonly updated_at?: string | null;
      };
      readonly ad_daily_metrics: ReadonlyArray<{
        readonly clicks?: number | null;
        readonly created_at?: string | null;
        readonly date: any;
        readonly id: string;
        readonly updated_at?: string | null;
        readonly variant_id?: string | null;
        readonly views?: number | null;
      }>;
    }>;
  } | null;
};

export type UpdateOneAdVariantMutationVariables = 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 UpdateOneAdVariantMutationQuery = {
  readonly update_ad_variants_by_pk?: {
    readonly active?: boolean | null;
    readonly ad_id: string;
    readonly content: Record<string, any>;
    readonly created_at?: string | null;
    readonly id: string;
    readonly is_control?: boolean | null;
    readonly performance_metrics?: Record<string, any> | null;
    readonly updated_at?: string | null;
    readonly ad: {
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    };
    readonly ad_daily_metrics: ReadonlyArray<{
      readonly clicks?: number | null;
      readonly created_at?: string | null;
      readonly date: any;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly variant_id?: string | null;
      readonly views?: number | null;
    }>;
  } | null;
};

export type UpdateManyAdVariantsManyMutationVariables = Exact<{
  updates: ReadonlyArray<AdVariantsUpdates> | AdVariantsUpdates;
}>;

export type UpdateManyAdVariantsManyMutationQuery = {
  readonly update_ad_variants_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly ad_id: string;
      readonly content: Record<string, any>;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_control?: boolean | null;
      readonly performance_metrics?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly ad: {
        readonly active?: boolean | null;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly id: string;
        readonly package_id?: string | null;
        readonly start_date: string;
        readonly updated_at?: string | null;
      };
      readonly ad_daily_metrics: ReadonlyArray<{
        readonly clicks?: number | null;
        readonly created_at?: string | null;
        readonly date: any;
        readonly id: string;
        readonly updated_at?: string | null;
        readonly variant_id?: string | null;
        readonly views?: number | null;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyAddressMutationVariables = Exact<{
  _inc?: InputMaybe<AddressesIncInput>;
  _set?: InputMaybe<AddressesSetInput>;
  where: AddressesBoolExp;
}>;

export type UpdateManyAddressMutationQuery = {
  readonly update_addresses?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
      readonly city: {
        readonly country_id: number;
        readonly id: number;
        readonly name: string;
        readonly state?: string | null;
      };
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly country: {
        readonly code: string;
        readonly code_3?: string | null;
        readonly id: number;
        readonly name: string;
      };
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneAddressMutationVariables = Exact<{
  _inc?: InputMaybe<AddressesIncInput>;
  _set?: InputMaybe<AddressesSetInput>;
  pk_columns: AddressesPkColumnsInput;
}>;

export type UpdateOneAddressMutationQuery = {
  readonly update_addresses_by_pk?: {
    readonly address_type?: any | null;
    readonly city_id: number;
    readonly company_id?: string | null;
    readonly country_id: number;
    readonly created_at?: string | null;
    readonly id: number;
    readonly is_primary?: boolean | null;
    readonly name?: string | null;
    readonly street1: string;
    readonly street2?: string | null;
    readonly updated_at?: string | null;
    readonly user_id?: string | null;
    readonly city: {
      readonly country_id: number;
      readonly id: number;
      readonly name: string;
      readonly state?: string | null;
    };
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly country: {
      readonly code: string;
      readonly code_3?: string | null;
      readonly id: number;
      readonly name: string;
    };
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type UpdateManyAddressesManyMutationVariables = Exact<{
  updates: ReadonlyArray<AddressesUpdates> | AddressesUpdates;
}>;

export type UpdateManyAddressesManyMutationQuery = {
  readonly update_addresses_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
      readonly city: {
        readonly country_id: number;
        readonly id: number;
        readonly name: string;
        readonly state?: string | null;
      };
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly country: {
        readonly code: string;
        readonly code_3?: string | null;
        readonly id: number;
        readonly name: string;
      };
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyAdMutationVariables = Exact<{
  _set?: InputMaybe<AdsSetInput>;
  where: AdsBoolExp;
}>;

export type UpdateManyAdMutationQuery = {
  readonly update_ads?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
      readonly ad_package?: {
        readonly active?: boolean | null;
        readonly avg_roi?: number | null;
        readonly created_at?: string | null;
        readonly description: string;
        readonly expected_ctr?: number | null;
        readonly features: ReadonlyArray<string>;
        readonly id: string;
        readonly name: string;
        readonly position: string;
        readonly price: number;
        readonly updated_at?: string | null;
        readonly view_frequency?: number | null;
      } | null;
      readonly ad_variants: ReadonlyArray<{
        readonly active?: boolean | null;
        readonly ad_id: string;
        readonly content: Record<string, any>;
        readonly created_at?: string | null;
        readonly id: string;
        readonly is_control?: boolean | null;
        readonly performance_metrics?: Record<string, any> | null;
        readonly updated_at?: string | null;
      }>;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null;
};

export type UpdateOneAdMutationVariables = Exact<{
  _set?: InputMaybe<AdsSetInput>;
  pk_columns: AdsPkColumnsInput;
}>;

export type UpdateOneAdMutationQuery = {
  readonly update_ads_by_pk?: {
    readonly active?: boolean | null;
    readonly company_id?: string | null;
    readonly created_at?: string | null;
    readonly end_date: string;
    readonly id: string;
    readonly package_id?: string | null;
    readonly start_date: string;
    readonly updated_at?: string | null;
    readonly ad_package?: {
      readonly active?: boolean | null;
      readonly avg_roi?: number | null;
      readonly created_at?: string | null;
      readonly description: string;
      readonly expected_ctr?: number | null;
      readonly features: ReadonlyArray<string>;
      readonly id: string;
      readonly name: string;
      readonly position: string;
      readonly price: number;
      readonly updated_at?: string | null;
      readonly view_frequency?: number | null;
    } | null;
    readonly ad_variants: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly ad_id: string;
      readonly content: Record<string, any>;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_control?: boolean | null;
      readonly performance_metrics?: Record<string, any> | null;
      readonly updated_at?: string | null;
    }>;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type UpdateManyAdsManyMutationVariables = Exact<{
  updates: ReadonlyArray<AdsUpdates> | AdsUpdates;
}>;

export type UpdateManyAdsManyMutationQuery = {
  readonly update_ads_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
      readonly ad_package?: {
        readonly active?: boolean | null;
        readonly avg_roi?: number | null;
        readonly created_at?: string | null;
        readonly description: string;
        readonly expected_ctr?: number | null;
        readonly features: ReadonlyArray<string>;
        readonly id: string;
        readonly name: string;
        readonly position: string;
        readonly price: number;
        readonly updated_at?: string | null;
        readonly view_frequency?: number | null;
      } | null;
      readonly ad_variants: ReadonlyArray<{
        readonly active?: boolean | null;
        readonly ad_id: string;
        readonly content: Record<string, any>;
        readonly created_at?: string | null;
        readonly id: string;
        readonly is_control?: boolean | null;
        readonly performance_metrics?: Record<string, any> | null;
        readonly updated_at?: string | null;
      }>;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyBlacklistedDomainMutationVariables = Exact<{
  _set?: InputMaybe<BlacklistedDomainsSetInput>;
  where: BlacklistedDomainsBoolExp;
}>;

export type UpdateManyBlacklistedDomainMutationQuery = {
  readonly update_blacklisted_domains?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at: string;
      readonly id: string;
      readonly reason?: string | null;
      readonly url: string;
    }>;
  } | null;
};

export type UpdateOneBlacklistedDomainMutationVariables = Exact<{
  _set?: InputMaybe<BlacklistedDomainsSetInput>;
  pk_columns: BlacklistedDomainsPkColumnsInput;
}>;

export type UpdateOneBlacklistedDomainMutationQuery = {
  readonly update_blacklisted_domains_by_pk?: {
    readonly created_at: string;
    readonly id: string;
    readonly reason?: string | null;
    readonly url: string;
  } | null;
};

export type UpdateManyBlacklistedDomainsManyMutationVariables = Exact<{
  updates: ReadonlyArray<BlacklistedDomainsUpdates> | BlacklistedDomainsUpdates;
}>;

export type UpdateManyBlacklistedDomainsManyMutationQuery = {
  readonly update_blacklisted_domains_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at: string;
      readonly id: string;
      readonly reason?: string | null;
      readonly url: string;
    }>;
  } | null> | null;
};

export type UpdateManyBlacklistedUrlMutationVariables = Exact<{
  _inc?: InputMaybe<BlacklistedUrlsIncInput>;
  _set?: InputMaybe<BlacklistedUrlsSetInput>;
  where: BlacklistedUrlsBoolExp;
}>;

export type UpdateManyBlacklistedUrlMutationQuery = {
  readonly update_blacklisted_urls?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly id: number;
      readonly reason?: string | null;
      readonly url: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null;
};

export type UpdateOneBlacklistedUrlMutationVariables = Exact<{
  _inc?: InputMaybe<BlacklistedUrlsIncInput>;
  _set?: InputMaybe<BlacklistedUrlsSetInput>;
  pk_columns: BlacklistedUrlsPkColumnsInput;
}>;

export type UpdateOneBlacklistedUrlMutationQuery = {
  readonly update_blacklisted_urls_by_pk?: {
    readonly company_id?: string | null;
    readonly created_at?: string | null;
    readonly id: number;
    readonly reason?: string | null;
    readonly url: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type UpdateManyBlacklistedUrlsManyMutationVariables = Exact<{
  updates: ReadonlyArray<BlacklistedUrlsUpdates> | BlacklistedUrlsUpdates;
}>;

export type UpdateManyBlacklistedUrlsManyMutationQuery = {
  readonly update_blacklisted_urls_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly id: number;
      readonly reason?: string | null;
      readonly url: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyBlockedIpMutationVariables = Exact<{
  _inc?: InputMaybe<BlockedIpsIncInput>;
  _set?: InputMaybe<BlockedIpsSetInput>;
  where: BlockedIpsBoolExp;
}>;

export type UpdateManyBlockedIpMutationQuery = {
  readonly update_blocked_ips?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly blocked_at?: string | null;
      readonly blocked_until: string;
      readonly created_at?: string | null;
      readonly failed_attempts?: number | null;
      readonly id: string;
      readonly ip_address: any;
      readonly reason?: string | null;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type UpdateOneBlockedIpMutationVariables = Exact<{
  _inc?: InputMaybe<BlockedIpsIncInput>;
  _set?: InputMaybe<BlockedIpsSetInput>;
  pk_columns: BlockedIpsPkColumnsInput;
}>;

export type UpdateOneBlockedIpMutationQuery = {
  readonly update_blocked_ips_by_pk?: {
    readonly blocked_at?: string | null;
    readonly blocked_until: string;
    readonly created_at?: string | null;
    readonly failed_attempts?: number | null;
    readonly id: string;
    readonly ip_address: any;
    readonly reason?: string | null;
    readonly updated_at?: string | null;
  } | null;
};

export type UpdateManyBlockedIpsManyMutationVariables = Exact<{
  updates: ReadonlyArray<BlockedIpsUpdates> | BlockedIpsUpdates;
}>;

export type UpdateManyBlockedIpsManyMutationQuery = {
  readonly update_blocked_ips_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly blocked_at?: string | null;
      readonly blocked_until: string;
      readonly created_at?: string | null;
      readonly failed_attempts?: number | null;
      readonly id: string;
      readonly ip_address: any;
      readonly reason?: string | null;
      readonly updated_at?: string | null;
    }>;
  } | null> | null;
};

export type UpdateManyBookmarkFolderMutationVariables = Exact<{
  _inc?: InputMaybe<BookmarkFoldersIncInput>;
  _set?: InputMaybe<BookmarkFoldersSetInput>;
  where: BookmarkFoldersBoolExp;
}>;

export type UpdateManyBookmarkFolderMutationQuery = {
  readonly update_bookmark_folders?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly color?: string | null;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_default?: boolean | null;
      readonly is_favorite?: boolean | null;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly path?: any | null;
      readonly position?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly bookmarks: ReadonlyArray<{
        readonly content_id: string;
        readonly content_type: string;
        readonly created_at?: string | null;
        readonly folder_id?: string | null;
        readonly id: string;
        readonly metadata?: Record<string, any> | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
    }>;
  } | null;
};

export type UpdateOneBookmarkFolderMutationVariables = Exact<{
  _inc?: InputMaybe<BookmarkFoldersIncInput>;
  _set?: InputMaybe<BookmarkFoldersSetInput>;
  pk_columns: BookmarkFoldersPkColumnsInput;
}>;

export type UpdateOneBookmarkFolderMutationQuery = {
  readonly update_bookmark_folders_by_pk?: {
    readonly color?: string | null;
    readonly created_at?: string | null;
    readonly id: string;
    readonly is_default?: boolean | null;
    readonly is_favorite?: boolean | null;
    readonly name: string;
    readonly parent_id?: string | null;
    readonly path?: any | null;
    readonly position?: number | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly bookmarks: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly folder_id?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  } | null;
};

export type UpdateManyBookmarkFoldersManyMutationVariables = Exact<{
  updates: ReadonlyArray<BookmarkFoldersUpdates> | BookmarkFoldersUpdates;
}>;

export type UpdateManyBookmarkFoldersManyMutationQuery = {
  readonly update_bookmark_folders_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly color?: string | null;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_default?: boolean | null;
      readonly is_favorite?: boolean | null;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly path?: any | null;
      readonly position?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly bookmarks: ReadonlyArray<{
        readonly content_id: string;
        readonly content_type: string;
        readonly created_at?: string | null;
        readonly folder_id?: string | null;
        readonly id: string;
        readonly metadata?: Record<string, any> | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyBookmarkMutationVariables = 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 UpdateManyBookmarkMutationQuery = {
  readonly update_bookmarks?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly folder_id?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly bookmark_folder?: {
        readonly color?: string | null;
        readonly created_at?: string | null;
        readonly id: string;
        readonly is_default?: boolean | null;
        readonly is_favorite?: boolean | null;
        readonly name: string;
        readonly parent_id?: string | null;
        readonly path?: any | null;
        readonly position?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      } | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null;
};

export type UpdateOneBookmarkMutationVariables = 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 UpdateOneBookmarkMutationQuery = {
  readonly update_bookmarks_by_pk?: {
    readonly content_id: string;
    readonly content_type: string;
    readonly created_at?: string | null;
    readonly folder_id?: string | null;
    readonly id: string;
    readonly metadata?: Record<string, any> | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly bookmark_folder?: {
      readonly color?: string | null;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_default?: boolean | null;
      readonly is_favorite?: boolean | null;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly path?: any | null;
      readonly position?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    } | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type UpdateManyBookmarksManyMutationVariables = Exact<{
  updates: ReadonlyArray<BookmarksUpdates> | BookmarksUpdates;
}>;

export type UpdateManyBookmarksManyMutationQuery = {
  readonly update_bookmarks_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly folder_id?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly bookmark_folder?: {
        readonly color?: string | null;
        readonly created_at?: string | null;
        readonly id: string;
        readonly is_default?: boolean | null;
        readonly is_favorite?: boolean | null;
        readonly name: string;
        readonly parent_id?: string | null;
        readonly path?: any | null;
        readonly position?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      } | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null> | null;
};

export type UpdateManyBusinessDomainMutationVariables = Exact<{
  _set?: InputMaybe<BusinessDomainsSetInput>;
  where: BusinessDomainsBoolExp;
}>;

export type UpdateManyBusinessDomainMutationQuery = {
  readonly update_business_domains?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly id: string;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly slug: string;
      readonly updated_at?: string | null;
      readonly categorized_urls: ReadonlyArray<{
        readonly categorizer_version: string;
        readonly company_id?: string | null;
        readonly confidence: number;
        readonly content_hash?: string | null;
        readonly created_at?: string | null;
        readonly domain_id: string;
        readonly found_on?: string | null;
        readonly id: string;
        readonly priority?: any | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
    }>;
  } | null;
};

export type UpdateOneBusinessDomainMutationVariables = Exact<{
  _set?: InputMaybe<BusinessDomainsSetInput>;
  pk_columns: BusinessDomainsPkColumnsInput;
}>;

export type UpdateOneBusinessDomainMutationQuery = {
  readonly update_business_domains_by_pk?: {
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly id: string;
    readonly name: string;
    readonly parent_id?: string | null;
    readonly slug: string;
    readonly updated_at?: string | null;
    readonly categorized_urls: ReadonlyArray<{
      readonly categorizer_version: string;
      readonly company_id?: string | null;
      readonly confidence: number;
      readonly content_hash?: string | null;
      readonly created_at?: string | null;
      readonly domain_id: string;
      readonly found_on?: string | null;
      readonly id: string;
      readonly priority?: any | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
  } | null;
};

export type UpdateManyBusinessDomainsManyMutationVariables = Exact<{
  updates: ReadonlyArray<BusinessDomainsUpdates> | BusinessDomainsUpdates;
}>;

export type UpdateManyBusinessDomainsManyMutationQuery = {
  readonly update_business_domains_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly id: string;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly slug: string;
      readonly updated_at?: string | null;
      readonly categorized_urls: ReadonlyArray<{
        readonly categorizer_version: string;
        readonly company_id?: string | null;
        readonly confidence: number;
        readonly content_hash?: string | null;
        readonly created_at?: string | null;
        readonly domain_id: string;
        readonly found_on?: string | null;
        readonly id: string;
        readonly priority?: any | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyCategoryMutationVariables = Exact<{
  _inc?: InputMaybe<CategoriesIncInput>;
  _set?: InputMaybe<CategoriesSetInput>;
  where: CategoriesBoolExp;
}>;

export type UpdateManyCategoryMutationQuery = {
  readonly update_categories?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
      readonly companies: ReadonlyArray<{
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
      readonly content_categories: ReadonlyArray<{
        readonly category_id: number;
        readonly content_id: string;
        readonly is_primary: boolean;
      }>;
      readonly feed_categories: ReadonlyArray<{
        readonly category_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly news: ReadonlyArray<{
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
    }>;
  } | null;
};

export type UpdateOneCategoryMutationVariables = Exact<{
  _inc?: InputMaybe<CategoriesIncInput>;
  _set?: InputMaybe<CategoriesSetInput>;
  pk_columns: CategoriesPkColumnsInput;
}>;

export type UpdateOneCategoryMutationQuery = {
  readonly update_categories_by_pk?: {
    readonly body?: string | null;
    readonly created_at: string;
    readonly document_id?: string | null;
    readonly id: number;
    readonly locale?: string | null;
    readonly name: string;
    readonly published_at?: string | null;
    readonly updated_at?: string | null;
    readonly companies: ReadonlyArray<{
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
    readonly content_categories: ReadonlyArray<{
      readonly category_id: number;
      readonly content_id: string;
      readonly is_primary: boolean;
    }>;
    readonly feed_categories: ReadonlyArray<{
      readonly category_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly news: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
  } | null;
};

export type UpdateManyCategoriesManyMutationVariables = Exact<{
  updates: ReadonlyArray<CategoriesUpdates> | CategoriesUpdates;
}>;

export type UpdateManyCategoriesManyMutationQuery = {
  readonly update_categories_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
      readonly companies: ReadonlyArray<{
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
      readonly content_categories: ReadonlyArray<{
        readonly category_id: number;
        readonly content_id: string;
        readonly is_primary: boolean;
      }>;
      readonly feed_categories: ReadonlyArray<{
        readonly category_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly news: ReadonlyArray<{
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyCategorizedUrlMutationVariables = Exact<{
  _inc?: InputMaybe<CategorizedUrlsIncInput>;
  _set?: InputMaybe<CategorizedUrlsSetInput>;
  where: CategorizedUrlsBoolExp;
}>;

export type UpdateManyCategorizedUrlMutationQuery = {
  readonly update_categorized_urls?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly categorizer_version: string;
      readonly company_id?: string | null;
      readonly confidence: number;
      readonly content_hash?: string | null;
      readonly created_at?: string | null;
      readonly domain_id: string;
      readonly found_on?: string | null;
      readonly id: string;
      readonly priority?: any | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly business_domain: {
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly id: string;
        readonly name: string;
        readonly parent_id?: string | null;
        readonly slug: string;
        readonly updated_at?: string | null;
      };
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null;
};

export type UpdateOneCategorizedUrlMutationVariables = Exact<{
  _inc?: InputMaybe<CategorizedUrlsIncInput>;
  _set?: InputMaybe<CategorizedUrlsSetInput>;
  pk_columns: CategorizedUrlsPkColumnsInput;
}>;

export type UpdateOneCategorizedUrlMutationQuery = {
  readonly update_categorized_urls_by_pk?: {
    readonly categorizer_version: string;
    readonly company_id?: string | null;
    readonly confidence: number;
    readonly content_hash?: string | null;
    readonly created_at?: string | null;
    readonly domain_id: string;
    readonly found_on?: string | null;
    readonly id: string;
    readonly priority?: any | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly business_domain: {
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly id: string;
      readonly name: string;
      readonly parent_id?: string | null;
      readonly slug: string;
      readonly updated_at?: string | null;
    };
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type UpdateManyCategorizedUrlsManyMutationVariables = Exact<{
  updates: ReadonlyArray<CategorizedUrlsUpdates> | CategorizedUrlsUpdates;
}>;

export type UpdateManyCategorizedUrlsManyMutationQuery = {
  readonly update_categorized_urls_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly categorizer_version: string;
      readonly company_id?: string | null;
      readonly confidence: number;
      readonly content_hash?: string | null;
      readonly created_at?: string | null;
      readonly domain_id: string;
      readonly found_on?: string | null;
      readonly id: string;
      readonly priority?: any | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly business_domain: {
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly id: string;
        readonly name: string;
        readonly parent_id?: string | null;
        readonly slug: string;
        readonly updated_at?: string | null;
      };
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyCircuitBreakerStateMutationVariables = Exact<{
  _inc?: InputMaybe<CircuitBreakerStatesIncInput>;
  _set?: InputMaybe<CircuitBreakerStatesSetInput>;
  where: CircuitBreakerStatesBoolExp;
}>;

export type UpdateManyCircuitBreakerStateMutationQuery = {
  readonly update_circuit_breaker_states?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly failure_count?: number | null;
      readonly id: string;
      readonly job_name: string;
      readonly last_failure?: string | null;
      readonly last_success?: string | null;
      readonly state: string;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type UpdateOneCircuitBreakerStateMutationVariables = Exact<{
  _inc?: InputMaybe<CircuitBreakerStatesIncInput>;
  _set?: InputMaybe<CircuitBreakerStatesSetInput>;
  pk_columns: CircuitBreakerStatesPkColumnsInput;
}>;

export type UpdateOneCircuitBreakerStateMutationQuery = {
  readonly update_circuit_breaker_states_by_pk?: {
    readonly created_at?: string | null;
    readonly failure_count?: number | null;
    readonly id: string;
    readonly job_name: string;
    readonly last_failure?: string | null;
    readonly last_success?: string | null;
    readonly state: string;
    readonly updated_at?: string | null;
  } | null;
};

export type UpdateManyCircuitBreakerStatesManyMutationVariables = Exact<{
  updates:
    | ReadonlyArray<CircuitBreakerStatesUpdates>
    | CircuitBreakerStatesUpdates;
}>;

export type UpdateManyCircuitBreakerStatesManyMutationQuery = {
  readonly update_circuit_breaker_states_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly failure_count?: number | null;
      readonly id: string;
      readonly job_name: string;
      readonly last_failure?: string | null;
      readonly last_success?: string | null;
      readonly state: string;
      readonly updated_at?: string | null;
    }>;
  } | null> | null;
};

export type UpdateManyCityMutationVariables = Exact<{
  _inc?: InputMaybe<CitiesIncInput>;
  _set?: InputMaybe<CitiesSetInput>;
  where: CitiesBoolExp;
}>;

export type UpdateManyCityMutationQuery = {
  readonly update_cities?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly country_id: number;
      readonly id: number;
      readonly name: string;
      readonly state?: string | null;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly country: {
        readonly code: string;
        readonly code_3?: string | null;
        readonly id: number;
        readonly name: string;
      };
    }>;
  } | null;
};

export type UpdateOneCityMutationVariables = Exact<{
  _inc?: InputMaybe<CitiesIncInput>;
  _set?: InputMaybe<CitiesSetInput>;
  pk_columns: CitiesPkColumnsInput;
}>;

export type UpdateOneCityMutationQuery = {
  readonly update_cities_by_pk?: {
    readonly country_id: number;
    readonly id: number;
    readonly name: string;
    readonly state?: string | null;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly country: {
      readonly code: string;
      readonly code_3?: string | null;
      readonly id: number;
      readonly name: string;
    };
  } | null;
};

export type UpdateManyCitiesManyMutationVariables = Exact<{
  updates: ReadonlyArray<CitiesUpdates> | CitiesUpdates;
}>;

export type UpdateManyCitiesManyMutationQuery = {
  readonly update_cities_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly country_id: number;
      readonly id: number;
      readonly name: string;
      readonly state?: string | null;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly country: {
        readonly code: string;
        readonly code_3?: string | null;
        readonly id: number;
        readonly name: string;
      };
    }>;
  } | null> | null;
};

export type UpdateManyCommentMutationVariables = Exact<{
  _set?: InputMaybe<CommentsSetInput>;
  where: CommentsBoolExp;
}>;

export type UpdateManyCommentMutationQuery = {
  readonly update_comments?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content: string;
      readonly content_id: string;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly parent_comment_id?: string | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneCommentMutationVariables = Exact<{
  _set?: InputMaybe<CommentsSetInput>;
  pk_columns: CommentsPkColumnsInput;
}>;

export type UpdateOneCommentMutationQuery = {
  readonly update_comments_by_pk?: {
    readonly content: string;
    readonly content_id: string;
    readonly content_type: any;
    readonly created_at?: string | null;
    readonly id: string;
    readonly parent_comment_id?: string | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type UpdateManyCommentsManyMutationVariables = Exact<{
  updates: ReadonlyArray<CommentsUpdates> | CommentsUpdates;
}>;

export type UpdateManyCommentsManyMutationQuery = {
  readonly update_comments_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content: string;
      readonly content_id: string;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly parent_comment_id?: string | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyCompanyMutationVariables = 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 UpdateManyCompanyMutationQuery = {
  readonly update_companies?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly ads: ReadonlyArray<{
        readonly active?: boolean | null;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly id: string;
        readonly package_id?: string | null;
        readonly start_date: string;
        readonly updated_at?: string | null;
      }>;
      readonly blacklisted_urls: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly id: number;
        readonly reason?: string | null;
        readonly url: string;
      }>;
      readonly categorized_urls: ReadonlyArray<{
        readonly categorizer_version: string;
        readonly company_id?: string | null;
        readonly confidence: number;
        readonly content_hash?: string | null;
        readonly created_at?: string | null;
        readonly domain_id: string;
        readonly found_on?: string | null;
        readonly id: string;
        readonly priority?: any | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
      readonly categoryByCategoryId?: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly company_contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_id: number;
        readonly created_at: string;
        readonly id: number;
        readonly updated_at: string;
      }>;
      readonly company_extras: ReadonlyArray<{
        readonly body?: string | null;
        readonly category: string;
        readonly company_id?: string | null;
        readonly created_at: string;
        readonly found_count?: number | null;
        readonly id: number;
        readonly level: any;
        readonly review?: Record<string, any> | null;
        readonly success?: boolean | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
      readonly contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_type?: any | null;
        readonly created_at?: string | null;
        readonly email?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly phone?: string | null;
        readonly privacy_level?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly content_sources: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly expected_count?: any | null;
        readonly failed_count?: any | null;
        readonly has_failed?: boolean | null;
        readonly hash?: number | null;
        readonly id: number;
        readonly priority: any;
        readonly refreshed_at?: string | null;
        readonly rss_urls?: ReadonlyArray<string> | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
      readonly news: ReadonlyArray<{
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
      readonly social_medium?: {
        readonly created_at?: string | null;
        readonly facebook_url?: string | null;
        readonly id: number;
        readonly instagram_url?: string | null;
        readonly linkedin_url?: string | null;
        readonly twitter_url?: string | null;
        readonly updated_at?: string | null;
        readonly youtube_url?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneCompanyMutationVariables = 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 UpdateOneCompanyMutationQuery = {
  readonly update_companies_by_pk?: {
    readonly category?: string | null;
    readonly category_id?: number | null;
    readonly content_status: any;
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly failed_count?: any | null;
    readonly founding_year?: any | null;
    readonly id: string;
    readonly is_english?: boolean | null;
    readonly is_government?: boolean | null;
    readonly keywords?: Record<string, any> | null;
    readonly logo_url?: string | null;
    readonly name?: string | null;
    readonly scrape_frequency?: any | null;
    readonly scrape_rating?: any | null;
    readonly scraped_at?: string | null;
    readonly social_media_id?: number | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly ads: ReadonlyArray<{
      readonly active?: boolean | null;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly id: string;
      readonly package_id?: string | null;
      readonly start_date: string;
      readonly updated_at?: string | null;
    }>;
    readonly blacklisted_urls: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly id: number;
      readonly reason?: string | null;
      readonly url: string;
    }>;
    readonly categorized_urls: ReadonlyArray<{
      readonly categorizer_version: string;
      readonly company_id?: string | null;
      readonly confidence: number;
      readonly content_hash?: string | null;
      readonly created_at?: string | null;
      readonly domain_id: string;
      readonly found_on?: string | null;
      readonly id: string;
      readonly priority?: any | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
    readonly categoryByCategoryId?: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly company_contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_id: number;
      readonly created_at: string;
      readonly id: number;
      readonly updated_at: string;
    }>;
    readonly company_extras: ReadonlyArray<{
      readonly body?: string | null;
      readonly category: string;
      readonly company_id?: string | null;
      readonly created_at: string;
      readonly found_count?: number | null;
      readonly id: number;
      readonly level: any;
      readonly review?: Record<string, any> | null;
      readonly success?: boolean | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
    readonly contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly content_sources: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
    readonly news: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
    readonly social_medium?: {
      readonly created_at?: string | null;
      readonly facebook_url?: string | null;
      readonly id: number;
      readonly instagram_url?: string | null;
      readonly linkedin_url?: string | null;
      readonly twitter_url?: string | null;
      readonly updated_at?: string | null;
      readonly youtube_url?: string | null;
    } | null;
  } | null;
};

export type UpdateManyCompaniesManyMutationVariables = Exact<{
  updates: ReadonlyArray<CompaniesUpdates> | CompaniesUpdates;
}>;

export type UpdateManyCompaniesManyMutationQuery = {
  readonly update_companies_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly ads: ReadonlyArray<{
        readonly active?: boolean | null;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly id: string;
        readonly package_id?: string | null;
        readonly start_date: string;
        readonly updated_at?: string | null;
      }>;
      readonly blacklisted_urls: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly id: number;
        readonly reason?: string | null;
        readonly url: string;
      }>;
      readonly categorized_urls: ReadonlyArray<{
        readonly categorizer_version: string;
        readonly company_id?: string | null;
        readonly confidence: number;
        readonly content_hash?: string | null;
        readonly created_at?: string | null;
        readonly domain_id: string;
        readonly found_on?: string | null;
        readonly id: string;
        readonly priority?: any | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
      readonly categoryByCategoryId?: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly company_contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_id: number;
        readonly created_at: string;
        readonly id: number;
        readonly updated_at: string;
      }>;
      readonly company_extras: ReadonlyArray<{
        readonly body?: string | null;
        readonly category: string;
        readonly company_id?: string | null;
        readonly created_at: string;
        readonly found_count?: number | null;
        readonly id: number;
        readonly level: any;
        readonly review?: Record<string, any> | null;
        readonly success?: boolean | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
      readonly contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_type?: any | null;
        readonly created_at?: string | null;
        readonly email?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly phone?: string | null;
        readonly privacy_level?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly content_sources: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly expected_count?: any | null;
        readonly failed_count?: any | null;
        readonly has_failed?: boolean | null;
        readonly hash?: number | null;
        readonly id: number;
        readonly priority: any;
        readonly refreshed_at?: string | null;
        readonly rss_urls?: ReadonlyArray<string> | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
      readonly news: ReadonlyArray<{
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
      readonly social_medium?: {
        readonly created_at?: string | null;
        readonly facebook_url?: string | null;
        readonly id: number;
        readonly instagram_url?: string | null;
        readonly linkedin_url?: string | null;
        readonly twitter_url?: string | null;
        readonly updated_at?: string | null;
        readonly youtube_url?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyCompanyContactMutationVariables = Exact<{
  _inc?: InputMaybe<CompanyContactsIncInput>;
  _set?: InputMaybe<CompanyContactsSetInput>;
  where: CompanyContactsBoolExp;
}>;

export type UpdateManyCompanyContactMutationQuery = {
  readonly update_company_contacts?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_id: number;
      readonly created_at: string;
      readonly id: number;
      readonly updated_at: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly contact: {
        readonly company_id?: string | null;
        readonly contact_type?: any | null;
        readonly created_at?: string | null;
        readonly email?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly phone?: string | null;
        readonly privacy_level?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneCompanyContactMutationVariables = Exact<{
  _inc?: InputMaybe<CompanyContactsIncInput>;
  _set?: InputMaybe<CompanyContactsSetInput>;
  pk_columns: CompanyContactsPkColumnsInput;
}>;

export type UpdateOneCompanyContactMutationQuery = {
  readonly update_company_contacts_by_pk?: {
    readonly company_id?: string | null;
    readonly contact_id: number;
    readonly created_at: string;
    readonly id: number;
    readonly updated_at: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly contact: {
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    };
  } | null;
};

export type UpdateManyCompanyContactsManyMutationVariables = Exact<{
  updates: ReadonlyArray<CompanyContactsUpdates> | CompanyContactsUpdates;
}>;

export type UpdateManyCompanyContactsManyMutationQuery = {
  readonly update_company_contacts_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_id: number;
      readonly created_at: string;
      readonly id: number;
      readonly updated_at: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly contact: {
        readonly company_id?: string | null;
        readonly contact_type?: any | null;
        readonly created_at?: string | null;
        readonly email?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly phone?: string | null;
        readonly privacy_level?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyCompanyEmployeeMutationVariables = Exact<{
  _set?: InputMaybe<CompanyEmployeesSetInput>;
  where: CompanyEmployeesBoolExp;
}>;

export type UpdateManyCompanyEmployeeMutationQuery = {
  readonly update_company_employees?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly access_level: any;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date?: string | null;
      readonly id: string;
      readonly job_description?: string | null;
      readonly role: string;
      readonly start_date?: string | null;
      readonly status?: boolean | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneCompanyEmployeeMutationVariables = Exact<{
  _set?: InputMaybe<CompanyEmployeesSetInput>;
  pk_columns: CompanyEmployeesPkColumnsInput;
}>;

export type UpdateOneCompanyEmployeeMutationQuery = {
  readonly update_company_employees_by_pk?: {
    readonly access_level: any;
    readonly company_id?: string | null;
    readonly created_at?: string | null;
    readonly end_date?: string | null;
    readonly id: string;
    readonly job_description?: string | null;
    readonly role: string;
    readonly start_date?: string | null;
    readonly status?: boolean | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type UpdateManyCompanyEmployeesManyMutationVariables = Exact<{
  updates: ReadonlyArray<CompanyEmployeesUpdates> | CompanyEmployeesUpdates;
}>;

export type UpdateManyCompanyEmployeesManyMutationQuery = {
  readonly update_company_employees_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly access_level: any;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date?: string | null;
      readonly id: string;
      readonly job_description?: string | null;
      readonly role: string;
      readonly start_date?: string | null;
      readonly status?: boolean | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyCompanyExtraMutationVariables = 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 UpdateManyCompanyExtraMutationQuery = {
  readonly update_company_extras?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly body?: string | null;
      readonly category: string;
      readonly company_id?: string | null;
      readonly created_at: string;
      readonly found_count?: number | null;
      readonly id: number;
      readonly level: any;
      readonly review?: Record<string, any> | null;
      readonly success?: boolean | null;
      readonly updated_at: string;
      readonly url: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null;
};

export type UpdateOneCompanyExtraMutationVariables = 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 UpdateOneCompanyExtraMutationQuery = {
  readonly update_company_extras_by_pk?: {
    readonly body?: string | null;
    readonly category: string;
    readonly company_id?: string | null;
    readonly created_at: string;
    readonly found_count?: number | null;
    readonly id: number;
    readonly level: any;
    readonly review?: Record<string, any> | null;
    readonly success?: boolean | null;
    readonly updated_at: string;
    readonly url: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
  } | null;
};

export type UpdateManyCompanyExtrasManyMutationVariables = Exact<{
  updates: ReadonlyArray<CompanyExtrasUpdates> | CompanyExtrasUpdates;
}>;

export type UpdateManyCompanyExtrasManyMutationQuery = {
  readonly update_company_extras_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly body?: string | null;
      readonly category: string;
      readonly company_id?: string | null;
      readonly created_at: string;
      readonly found_count?: number | null;
      readonly id: number;
      readonly level: any;
      readonly review?: Record<string, any> | null;
      readonly success?: boolean | null;
      readonly updated_at: string;
      readonly url: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyCompanyMetricMutationVariables = 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 UpdateManyCompanyMetricMutationQuery = {
  readonly update_company_metrics?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id: string;
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
      readonly metric_definition?: {
        readonly category?: string | null;
        readonly description?: string | null;
        readonly id: number;
        readonly is_dimensional?: boolean | null;
        readonly name: string;
        readonly type: string;
        readonly unit?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneCompanyMetricMutationVariables = 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 UpdateOneCompanyMetricMutationQuery = {
  readonly update_company_metrics_by_pk?: {
    readonly company_id: string;
    readonly crawl_id: string;
    readonly id: number;
    readonly metric_id?: number | null;
    readonly timestamp: string;
    readonly value: Record<string, any>;
    readonly metric_definition?: {
      readonly category?: string | null;
      readonly description?: string | null;
      readonly id: number;
      readonly is_dimensional?: boolean | null;
      readonly name: string;
      readonly type: string;
      readonly unit?: string | null;
    } | null;
  } | null;
};

export type UpdateManyCompanyMetricsManyMutationVariables = Exact<{
  updates: ReadonlyArray<CompanyMetricsUpdates> | CompanyMetricsUpdates;
}>;

export type UpdateManyCompanyMetricsManyMutationQuery = {
  readonly update_company_metrics_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id: string;
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
      readonly metric_definition?: {
        readonly category?: string | null;
        readonly description?: string | null;
        readonly id: number;
        readonly is_dimensional?: boolean | null;
        readonly name: string;
        readonly type: string;
        readonly unit?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyContactMutationVariables = Exact<{
  _inc?: InputMaybe<ContactsIncInput>;
  _set?: InputMaybe<ContactsSetInput>;
  where: ContactsBoolExp;
}>;

export type UpdateManyContactMutationQuery = {
  readonly update_contacts?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly company_contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_id: number;
        readonly created_at: string;
        readonly id: number;
        readonly updated_at: string;
      }>;
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneContactMutationVariables = Exact<{
  _inc?: InputMaybe<ContactsIncInput>;
  _set?: InputMaybe<ContactsSetInput>;
  pk_columns: ContactsPkColumnsInput;
}>;

export type UpdateOneContactMutationQuery = {
  readonly update_contacts_by_pk?: {
    readonly company_id?: string | null;
    readonly contact_type?: any | null;
    readonly created_at?: string | null;
    readonly email?: string | null;
    readonly id: number;
    readonly is_primary?: boolean | null;
    readonly phone?: string | null;
    readonly privacy_level?: any | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly user_id?: string | null;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly company_contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_id: number;
      readonly created_at: string;
      readonly id: number;
      readonly updated_at: string;
    }>;
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type UpdateManyContactsManyMutationVariables = Exact<{
  updates: ReadonlyArray<ContactsUpdates> | ContactsUpdates;
}>;

export type UpdateManyContactsManyMutationQuery = {
  readonly update_contacts_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly company_contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_id: number;
        readonly created_at: string;
        readonly id: number;
        readonly updated_at: string;
      }>;
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyContentCategoryMutationVariables = Exact<{
  _inc?: InputMaybe<ContentCategoriesIncInput>;
  _set?: InputMaybe<ContentCategoriesSetInput>;
  where: ContentCategoriesBoolExp;
}>;

export type UpdateManyContentCategoryMutationQuery = {
  readonly update_content_categories?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category_id: number;
      readonly content_id: string;
      readonly is_primary: boolean;
      readonly category: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      };
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null;
};

export type UpdateOneContentCategoryMutationVariables = Exact<{
  _inc?: InputMaybe<ContentCategoriesIncInput>;
  _set?: InputMaybe<ContentCategoriesSetInput>;
  pk_columns: ContentCategoriesPkColumnsInput;
}>;

export type UpdateOneContentCategoryMutationQuery = {
  readonly update_content_categories_by_pk?: {
    readonly category_id: number;
    readonly content_id: string;
    readonly is_primary: boolean;
    readonly category: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    };
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type UpdateManyContentCategoriesManyMutationVariables = Exact<{
  updates: ReadonlyArray<ContentCategoriesUpdates> | ContentCategoriesUpdates;
}>;

export type UpdateManyContentCategoriesManyMutationQuery = {
  readonly update_content_categories_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category_id: number;
      readonly content_id: string;
      readonly is_primary: boolean;
      readonly category: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      };
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null> | null;
};

export type UpdateManyContentSourceVisitMutationVariables = Exact<{
  _set?: InputMaybe<ContentSourceVisitsSetInput>;
  where: ContentSourceVisitsBoolExp;
}>;

export type UpdateManyContentSourceVisitMutationQuery = {
  readonly update_content_source_visits?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneContentSourceVisitMutationVariables = Exact<{
  _set?: InputMaybe<ContentSourceVisitsSetInput>;
  pk_columns: ContentSourceVisitsPkColumnsInput;
}>;

export type UpdateOneContentSourceVisitMutationQuery = {
  readonly update_content_source_visits_by_pk?: {
    readonly content_id: string;
    readonly created_at?: string | null;
    readonly id: string;
    readonly user_id?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type UpdateManyContentSourceVisitsManyMutationVariables = Exact<{
  updates:
    | ReadonlyArray<ContentSourceVisitsUpdates>
    | ContentSourceVisitsUpdates;
}>;

export type UpdateManyContentSourceVisitsManyMutationQuery = {
  readonly update_content_source_visits_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyContentSourceMutationVariables = Exact<{
  _inc?: InputMaybe<ContentSourcesIncInput>;
  _set?: InputMaybe<ContentSourcesSetInput>;
  where: ContentSourcesBoolExp;
}>;

export type UpdateManyContentSourceMutationQuery = {
  readonly update_content_sources?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly feed_sources: ReadonlyArray<{
        readonly content_source_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly news: ReadonlyArray<{
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
    }>;
  } | null;
};

export type UpdateOneContentSourceMutationVariables = Exact<{
  _inc?: InputMaybe<ContentSourcesIncInput>;
  _set?: InputMaybe<ContentSourcesSetInput>;
  pk_columns: ContentSourcesPkColumnsInput;
}>;

export type UpdateOneContentSourceMutationQuery = {
  readonly update_content_sources_by_pk?: {
    readonly company_id?: string | null;
    readonly content_type: any;
    readonly created_at?: string | null;
    readonly expected_count?: any | null;
    readonly failed_count?: any | null;
    readonly has_failed?: boolean | null;
    readonly hash?: number | null;
    readonly id: number;
    readonly priority: any;
    readonly refreshed_at?: string | null;
    readonly rss_urls?: ReadonlyArray<string> | null;
    readonly scrape_frequency: any;
    readonly scraped_at?: string | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly feed_sources: ReadonlyArray<{
      readonly content_source_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly news: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    }>;
  } | null;
};

export type UpdateManyContentSourcesManyMutationVariables = Exact<{
  updates: ReadonlyArray<ContentSourcesUpdates> | ContentSourcesUpdates;
}>;

export type UpdateManyContentSourcesManyMutationQuery = {
  readonly update_content_sources_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly feed_sources: ReadonlyArray<{
        readonly content_source_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly news: ReadonlyArray<{
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyContentStatusMutationVariables = Exact<{
  _set?: InputMaybe<ContentStatusesSetInput>;
  where: ContentStatusesBoolExp;
}>;

export type UpdateManyContentStatusMutationQuery = {
  readonly update_content_statuses?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly notes?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null;
};

export type UpdateOneContentStatusMutationVariables = Exact<{
  _set?: InputMaybe<ContentStatusesSetInput>;
  pk_columns: ContentStatusesPkColumnsInput;
}>;

export type UpdateOneContentStatusMutationQuery = {
  readonly update_content_statuses_by_pk?: {
    readonly content_id: string;
    readonly content_status: any;
    readonly created_at?: string | null;
    readonly id: string;
    readonly notes?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type UpdateManyContentStatusesManyMutationVariables = Exact<{
  updates: ReadonlyArray<ContentStatusesUpdates> | ContentStatusesUpdates;
}>;

export type UpdateManyContentStatusesManyMutationQuery = {
  readonly update_content_statuses_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly notes?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null> | null;
};

export type UpdateManyContentTagMutationVariables = Exact<{
  _inc?: InputMaybe<ContentTagsIncInput>;
  _set?: InputMaybe<ContentTagsSetInput>;
  where: ContentTagsBoolExp;
}>;

export type UpdateManyContentTagMutationQuery = {
  readonly update_content_tags?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly tag_id: number;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly tag: {
        readonly body?: string | null;
        readonly created_at?: string | null;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneContentTagMutationVariables = Exact<{
  _inc?: InputMaybe<ContentTagsIncInput>;
  _set?: InputMaybe<ContentTagsSetInput>;
  pk_columns: ContentTagsPkColumnsInput;
}>;

export type UpdateOneContentTagMutationQuery = {
  readonly update_content_tags_by_pk?: {
    readonly content_id: string;
    readonly tag_id: number;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly tag: {
      readonly body?: string | null;
      readonly created_at?: string | null;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    };
  } | null;
};

export type UpdateManyContentTagsManyMutationVariables = Exact<{
  updates: ReadonlyArray<ContentTagsUpdates> | ContentTagsUpdates;
}>;

export type UpdateManyContentTagsManyMutationQuery = {
  readonly update_content_tags_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly tag_id: number;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly tag: {
        readonly body?: string | null;
        readonly created_at?: string | null;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyContentMutationVariables = Exact<{
  _inc?: InputMaybe<ContentsIncInput>;
  _set?: InputMaybe<ContentsSetInput>;
  where: ContentsBoolExp;
}>;

export type UpdateManyContentMutationQuery = {
  readonly update_contents?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly bookmarks: ReadonlyArray<{
        readonly content_id: string;
        readonly content_type: string;
        readonly created_at?: string | null;
        readonly folder_id?: string | null;
        readonly id: string;
        readonly metadata?: Record<string, any> | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly content_categories: ReadonlyArray<{
        readonly category_id: number;
        readonly content_id: string;
        readonly is_primary: boolean;
      }>;
      readonly content_source_visits: ReadonlyArray<{
        readonly content_id: string;
        readonly created_at?: string | null;
        readonly id: string;
        readonly user_id?: string | null;
      }>;
      readonly content_statuses: ReadonlyArray<{
        readonly content_id: string;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly id: string;
        readonly notes?: string | null;
      }>;
      readonly content_tags: ReadonlyArray<{
        readonly content_id: string;
        readonly tag_id: number;
      }>;
      readonly news?: {
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      } | null;
      readonly newsletter?: {
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly frequency: string;
        readonly generated_content?: string | null;
        readonly id: string;
        readonly start_date: string;
        readonly title: string;
        readonly updated_at?: string | null;
      } | null;
      readonly research?: {
        readonly abstract?: string | null;
        readonly abstract_url: string;
        readonly affiliations?: Record<string, any> | null;
        readonly authors?: Record<string, any> | null;
        readonly category?: string | null;
        readonly comments?: string | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly doi_url?: string | null;
        readonly figure_count?: any | null;
        readonly has_embedding?: boolean | null;
        readonly id: string;
        readonly is_flagged: boolean;
        readonly keywords?: string | null;
        readonly month?: string | null;
        readonly page_count?: any | null;
        readonly pdf_url?: string | null;
        readonly published_at?: string | null;
        readonly published_in?: string | null;
        readonly summary?: string | null;
        readonly table_count?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly version?: any | null;
        readonly year?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneContentMutationVariables = Exact<{
  _inc?: InputMaybe<ContentsIncInput>;
  _set?: InputMaybe<ContentsSetInput>;
  pk_columns: ContentsPkColumnsInput;
}>;

export type UpdateOneContentMutationQuery = {
  readonly update_contents_by_pk?: {
    readonly content_type: any;
    readonly created_at?: string | null;
    readonly hot_score?: any | null;
    readonly id: string;
    readonly rss_url?: string | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly url: string;
    readonly bookmarks: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly folder_id?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly content_categories: ReadonlyArray<{
      readonly category_id: number;
      readonly content_id: string;
      readonly is_primary: boolean;
    }>;
    readonly content_source_visits: ReadonlyArray<{
      readonly content_id: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id?: string | null;
    }>;
    readonly content_statuses: ReadonlyArray<{
      readonly content_id: string;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly notes?: string | null;
    }>;
    readonly content_tags: ReadonlyArray<{
      readonly content_id: string;
      readonly tag_id: number;
    }>;
    readonly news?: {
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    } | null;
    readonly newsletter?: {
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly frequency: string;
      readonly generated_content?: string | null;
      readonly id: string;
      readonly start_date: string;
      readonly title: string;
      readonly updated_at?: string | null;
    } | null;
    readonly research?: {
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
    } | null;
  } | null;
};

export type UpdateManyContentsManyMutationVariables = Exact<{
  updates: ReadonlyArray<ContentsUpdates> | ContentsUpdates;
}>;

export type UpdateManyContentsManyMutationQuery = {
  readonly update_contents_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
      readonly bookmarks: ReadonlyArray<{
        readonly content_id: string;
        readonly content_type: string;
        readonly created_at?: string | null;
        readonly folder_id?: string | null;
        readonly id: string;
        readonly metadata?: Record<string, any> | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly content_categories: ReadonlyArray<{
        readonly category_id: number;
        readonly content_id: string;
        readonly is_primary: boolean;
      }>;
      readonly content_source_visits: ReadonlyArray<{
        readonly content_id: string;
        readonly created_at?: string | null;
        readonly id: string;
        readonly user_id?: string | null;
      }>;
      readonly content_statuses: ReadonlyArray<{
        readonly content_id: string;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly id: string;
        readonly notes?: string | null;
      }>;
      readonly content_tags: ReadonlyArray<{
        readonly content_id: string;
        readonly tag_id: number;
      }>;
      readonly news?: {
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      } | null;
      readonly newsletter?: {
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly end_date: string;
        readonly frequency: string;
        readonly generated_content?: string | null;
        readonly id: string;
        readonly start_date: string;
        readonly title: string;
        readonly updated_at?: string | null;
      } | null;
      readonly research?: {
        readonly abstract?: string | null;
        readonly abstract_url: string;
        readonly affiliations?: Record<string, any> | null;
        readonly authors?: Record<string, any> | null;
        readonly category?: string | null;
        readonly comments?: string | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly doi_url?: string | null;
        readonly figure_count?: any | null;
        readonly has_embedding?: boolean | null;
        readonly id: string;
        readonly is_flagged: boolean;
        readonly keywords?: string | null;
        readonly month?: string | null;
        readonly page_count?: any | null;
        readonly pdf_url?: string | null;
        readonly published_at?: string | null;
        readonly published_in?: string | null;
        readonly summary?: string | null;
        readonly table_count?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly version?: any | null;
        readonly year?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyCountryMutationVariables = Exact<{
  _inc?: InputMaybe<CountriesIncInput>;
  _set?: InputMaybe<CountriesSetInput>;
  where: CountriesBoolExp;
}>;

export type UpdateManyCountryMutationQuery = {
  readonly update_countries?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly code: string;
      readonly code_3?: string | null;
      readonly id: number;
      readonly name: string;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly cities: ReadonlyArray<{
        readonly country_id: number;
        readonly id: number;
        readonly name: string;
        readonly state?: string | null;
      }>;
    }>;
  } | null;
};

export type UpdateOneCountryMutationVariables = Exact<{
  _inc?: InputMaybe<CountriesIncInput>;
  _set?: InputMaybe<CountriesSetInput>;
  pk_columns: CountriesPkColumnsInput;
}>;

export type UpdateOneCountryMutationQuery = {
  readonly update_countries_by_pk?: {
    readonly code: string;
    readonly code_3?: string | null;
    readonly id: number;
    readonly name: string;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly cities: ReadonlyArray<{
      readonly country_id: number;
      readonly id: number;
      readonly name: string;
      readonly state?: string | null;
    }>;
  } | null;
};

export type UpdateManyCountriesManyMutationVariables = Exact<{
  updates: ReadonlyArray<CountriesUpdates> | CountriesUpdates;
}>;

export type UpdateManyCountriesManyMutationQuery = {
  readonly update_countries_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly code: string;
      readonly code_3?: string | null;
      readonly id: number;
      readonly name: string;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly cities: ReadonlyArray<{
        readonly country_id: number;
        readonly id: number;
        readonly name: string;
        readonly state?: string | null;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyCustomerPaymentMutationVariables = 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 UpdateManyCustomerPaymentMutationQuery = {
  readonly update_customer_payments?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
      readonly customer_refunds: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly batch_id?: string | null;
        readonly created_at?: string | null;
        readonly currency?: string | null;
        readonly external_refund_id: string;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly payment_id: number;
        readonly receipt?: string | null;
        readonly speed_processed?: string | null;
        readonly speed_requested?: string | null;
        readonly status: string;
      }>;
      readonly customer_subscription?: {
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      } | null;
      readonly payment_provider: {
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_active?: boolean | null;
        readonly name: string;
        readonly updated_at?: string | null;
      };
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneCustomerPaymentMutationVariables = 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 UpdateOneCustomerPaymentMutationQuery = {
  readonly update_customer_payments_by_pk?: {
    readonly acquirer_data?: Record<string, any> | null;
    readonly amount: number;
    readonly amount_refunded?: number | null;
    readonly amount_transferred?: number | null;
    readonly bank?: string | null;
    readonly captured?: boolean | null;
    readonly created_at?: string | null;
    readonly currency: string;
    readonly description?: string | null;
    readonly error_code?: string | null;
    readonly error_description?: string | null;
    readonly error_reason?: string | null;
    readonly error_source?: string | null;
    readonly error_step?: string | null;
    readonly external_order_id?: string | null;
    readonly external_payment_id: string;
    readonly fee?: number | null;
    readonly id: number;
    readonly international?: boolean | null;
    readonly invoice_id?: string | null;
    readonly method?: string | null;
    readonly notes?: Record<string, any> | null;
    readonly order_id?: string | null;
    readonly payment_provider_id: number;
    readonly refund_status?: string | null;
    readonly status: string;
    readonly subscription_id?: number | null;
    readonly tax?: number | null;
    readonly user_id: string;
    readonly vpa?: string | null;
    readonly wallet?: string | null;
    readonly customer_refunds: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly batch_id?: string | null;
      readonly created_at?: string | null;
      readonly currency?: string | null;
      readonly external_refund_id: string;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly payment_id: number;
      readonly receipt?: string | null;
      readonly speed_processed?: string | null;
      readonly speed_requested?: string | null;
      readonly status: string;
    }>;
    readonly customer_subscription?: {
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    } | null;
    readonly payment_provider: {
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_active?: boolean | null;
      readonly name: string;
      readonly updated_at?: string | null;
    };
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type UpdateManyCustomerPaymentsManyMutationVariables = Exact<{
  updates: ReadonlyArray<CustomerPaymentsUpdates> | CustomerPaymentsUpdates;
}>;

export type UpdateManyCustomerPaymentsManyMutationQuery = {
  readonly update_customer_payments_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
      readonly customer_refunds: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly batch_id?: string | null;
        readonly created_at?: string | null;
        readonly currency?: string | null;
        readonly external_refund_id: string;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly payment_id: number;
        readonly receipt?: string | null;
        readonly speed_processed?: string | null;
        readonly speed_requested?: string | null;
        readonly status: string;
      }>;
      readonly customer_subscription?: {
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      } | null;
      readonly payment_provider: {
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_active?: boolean | null;
        readonly name: string;
        readonly updated_at?: string | null;
      };
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyCustomerProcessedWebhookMutationVariables = Exact<{
  _inc?: InputMaybe<CustomerProcessedWebhooksIncInput>;
  _set?: InputMaybe<CustomerProcessedWebhooksSetInput>;
  where: CustomerProcessedWebhooksBoolExp;
}>;

export type UpdateManyCustomerProcessedWebhookMutationQuery = {
  readonly update_customer_processed_webhooks?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly event_id: string;
      readonly event_type: string;
      readonly id: number;
      readonly processed_at: string;
    }>;
  } | null;
};

export type UpdateOneCustomerProcessedWebhookMutationVariables = Exact<{
  _inc?: InputMaybe<CustomerProcessedWebhooksIncInput>;
  _set?: InputMaybe<CustomerProcessedWebhooksSetInput>;
  pk_columns: CustomerProcessedWebhooksPkColumnsInput;
}>;

export type UpdateOneCustomerProcessedWebhookMutationQuery = {
  readonly update_customer_processed_webhooks_by_pk?: {
    readonly event_id: string;
    readonly event_type: string;
    readonly id: number;
    readonly processed_at: string;
  } | null;
};

export type UpdateManyCustomerProcessedWebhooksManyMutationVariables = Exact<{
  updates:
    | ReadonlyArray<CustomerProcessedWebhooksUpdates>
    | CustomerProcessedWebhooksUpdates;
}>;

export type UpdateManyCustomerProcessedWebhooksManyMutationQuery = {
  readonly update_customer_processed_webhooks_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly event_id: string;
      readonly event_type: string;
      readonly id: number;
      readonly processed_at: string;
    }>;
  } | null> | null;
};

export type UpdateManyCustomerRefundMutationVariables = 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 UpdateManyCustomerRefundMutationQuery = {
  readonly update_customer_refunds?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly batch_id?: string | null;
      readonly created_at?: string | null;
      readonly currency?: string | null;
      readonly external_refund_id: string;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly payment_id: number;
      readonly receipt?: string | null;
      readonly speed_processed?: string | null;
      readonly speed_requested?: string | null;
      readonly status: string;
      readonly customer_payment: {
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneCustomerRefundMutationVariables = 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 UpdateOneCustomerRefundMutationQuery = {
  readonly update_customer_refunds_by_pk?: {
    readonly acquirer_data?: Record<string, any> | null;
    readonly amount: number;
    readonly batch_id?: string | null;
    readonly created_at?: string | null;
    readonly currency?: string | null;
    readonly external_refund_id: string;
    readonly id: number;
    readonly notes?: Record<string, any> | null;
    readonly payment_id: number;
    readonly receipt?: string | null;
    readonly speed_processed?: string | null;
    readonly speed_requested?: string | null;
    readonly status: string;
    readonly customer_payment: {
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    };
  } | null;
};

export type UpdateManyCustomerRefundsManyMutationVariables = Exact<{
  updates: ReadonlyArray<CustomerRefundsUpdates> | CustomerRefundsUpdates;
}>;

export type UpdateManyCustomerRefundsManyMutationQuery = {
  readonly update_customer_refunds_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly batch_id?: string | null;
      readonly created_at?: string | null;
      readonly currency?: string | null;
      readonly external_refund_id: string;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly payment_id: number;
      readonly receipt?: string | null;
      readonly speed_processed?: string | null;
      readonly speed_requested?: string | null;
      readonly status: string;
      readonly customer_payment: {
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyCustomerSubscriptionPlanMutationVariables = 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 UpdateManyCustomerSubscriptionPlanMutationQuery = {
  readonly update_customer_subscription_plans?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly annual_amount: number;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly external_plan_id?: string | null;
      readonly features?: Record<string, any> | null;
      readonly id: number;
      readonly interval: number;
      readonly interval_type: string;
      readonly is_active?: boolean | null;
      readonly monthly_amount: number;
      readonly name: string;
      readonly updated_at?: string | null;
      readonly customer_subscriptions: ReadonlyArray<{
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
    }>;
  } | null;
};

export type UpdateOneCustomerSubscriptionPlanMutationVariables = 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 UpdateOneCustomerSubscriptionPlanMutationQuery = {
  readonly update_customer_subscription_plans_by_pk?: {
    readonly annual_amount: number;
    readonly created_at?: string | null;
    readonly currency: string;
    readonly description?: string | null;
    readonly external_plan_id?: string | null;
    readonly features?: Record<string, any> | null;
    readonly id: number;
    readonly interval: number;
    readonly interval_type: string;
    readonly is_active?: boolean | null;
    readonly monthly_amount: number;
    readonly name: string;
    readonly updated_at?: string | null;
    readonly customer_subscriptions: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  } | null;
};

export type UpdateManyCustomerSubscriptionPlansManyMutationVariables = Exact<{
  updates:
    | ReadonlyArray<CustomerSubscriptionPlansUpdates>
    | CustomerSubscriptionPlansUpdates;
}>;

export type UpdateManyCustomerSubscriptionPlansManyMutationQuery = {
  readonly update_customer_subscription_plans_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly annual_amount: number;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly external_plan_id?: string | null;
      readonly features?: Record<string, any> | null;
      readonly id: number;
      readonly interval: number;
      readonly interval_type: string;
      readonly is_active?: boolean | null;
      readonly monthly_amount: number;
      readonly name: string;
      readonly updated_at?: string | null;
      readonly customer_subscriptions: ReadonlyArray<{
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyCustomerSubscriptionMutationVariables = 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 UpdateManyCustomerSubscriptionMutationQuery = {
  readonly update_customer_subscriptions?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly customer_payments: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      }>;
      readonly customer_subscription_plan: {
        readonly annual_amount: number;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly external_plan_id?: string | null;
        readonly features?: Record<string, any> | null;
        readonly id: number;
        readonly interval: number;
        readonly interval_type: string;
        readonly is_active?: boolean | null;
        readonly monthly_amount: number;
        readonly name: string;
        readonly updated_at?: string | null;
      };
      readonly payment_provider: {
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_active?: boolean | null;
        readonly name: string;
        readonly updated_at?: string | null;
      };
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneCustomerSubscriptionMutationVariables = 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 UpdateOneCustomerSubscriptionMutationQuery = {
  readonly update_customer_subscriptions_by_pk?: {
    readonly auth_attempts?: number | null;
    readonly cancel_at_period_end?: boolean | null;
    readonly cancel_initiated_by?: string | null;
    readonly change_scheduled_at?: string | null;
    readonly charge_at?: string | null;
    readonly created_at?: string | null;
    readonly current_end: string;
    readonly current_start: string;
    readonly customer_notify?: boolean | null;
    readonly end_at?: string | null;
    readonly ended_at?: string | null;
    readonly expire_by?: string | null;
    readonly external_subscription_id: string;
    readonly has_scheduled_changes?: boolean | null;
    readonly id: number;
    readonly notes?: Record<string, any> | null;
    readonly offer_id?: string | null;
    readonly paid_count?: number | null;
    readonly pause_initiated_by?: string | null;
    readonly payment_provider_id: number;
    readonly plan_id: number;
    readonly quantity?: number | null;
    readonly remaining_count?: number | null;
    readonly short_url?: string | null;
    readonly source?: string | null;
    readonly start_at?: string | null;
    readonly status: string;
    readonly total_count?: number | null;
    readonly type?: number | null;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly customer_payments: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
    readonly customer_subscription_plan: {
      readonly annual_amount: number;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly external_plan_id?: string | null;
      readonly features?: Record<string, any> | null;
      readonly id: number;
      readonly interval: number;
      readonly interval_type: string;
      readonly is_active?: boolean | null;
      readonly monthly_amount: number;
      readonly name: string;
      readonly updated_at?: string | null;
    };
    readonly payment_provider: {
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_active?: boolean | null;
      readonly name: string;
      readonly updated_at?: string | null;
    };
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type UpdateManyCustomerSubscriptionsManyMutationVariables = Exact<{
  updates:
    | ReadonlyArray<CustomerSubscriptionsUpdates>
    | CustomerSubscriptionsUpdates;
}>;

export type UpdateManyCustomerSubscriptionsManyMutationQuery = {
  readonly update_customer_subscriptions_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly customer_payments: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      }>;
      readonly customer_subscription_plan: {
        readonly annual_amount: number;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly external_plan_id?: string | null;
        readonly features?: Record<string, any> | null;
        readonly id: number;
        readonly interval: number;
        readonly interval_type: string;
        readonly is_active?: boolean | null;
        readonly monthly_amount: number;
        readonly name: string;
        readonly updated_at?: string | null;
      };
      readonly payment_provider: {
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_active?: boolean | null;
        readonly name: string;
        readonly updated_at?: string | null;
      };
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyEmbeddingReviewMutationVariables = Exact<{
  _inc?: InputMaybe<EmbeddingReviewsIncInput>;
  _set?: InputMaybe<EmbeddingReviewsSetInput>;
  where: EmbeddingReviewsBoolExp;
}>;

export type UpdateManyEmbeddingReviewMutationQuery = {
  readonly update_embedding_reviews?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly agent_review?: boolean | null;
      readonly created_at: string;
      readonly human_review?: boolean | null;
      readonly id: number;
      readonly notes?: string | null;
      readonly updated_at?: string | null;
      readonly research_embeddings: ReadonlyArray<{
        readonly chunk: string;
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly embedding_review_id?: number | null;
        readonly id: number;
        readonly is_flagged?: boolean | null;
        readonly research_id: string;
        readonly updated_at: string;
        readonly url?: string | null;
      }>;
    }>;
  } | null;
};

export type UpdateOneEmbeddingReviewMutationVariables = Exact<{
  _inc?: InputMaybe<EmbeddingReviewsIncInput>;
  _set?: InputMaybe<EmbeddingReviewsSetInput>;
  pk_columns: EmbeddingReviewsPkColumnsInput;
}>;

export type UpdateOneEmbeddingReviewMutationQuery = {
  readonly update_embedding_reviews_by_pk?: {
    readonly agent_review?: boolean | null;
    readonly created_at: string;
    readonly human_review?: boolean | null;
    readonly id: number;
    readonly notes?: string | null;
    readonly updated_at?: string | null;
    readonly research_embeddings: ReadonlyArray<{
      readonly chunk: string;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly embedding_review_id?: number | null;
      readonly id: number;
      readonly is_flagged?: boolean | null;
      readonly research_id: string;
      readonly updated_at: string;
      readonly url?: string | null;
    }>;
  } | null;
};

export type UpdateManyEmbeddingReviewsManyMutationVariables = Exact<{
  updates: ReadonlyArray<EmbeddingReviewsUpdates> | EmbeddingReviewsUpdates;
}>;

export type UpdateManyEmbeddingReviewsManyMutationQuery = {
  readonly update_embedding_reviews_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly agent_review?: boolean | null;
      readonly created_at: string;
      readonly human_review?: boolean | null;
      readonly id: number;
      readonly notes?: string | null;
      readonly updated_at?: string | null;
      readonly research_embeddings: ReadonlyArray<{
        readonly chunk: string;
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly embedding_review_id?: number | null;
        readonly id: number;
        readonly is_flagged?: boolean | null;
        readonly research_id: string;
        readonly updated_at: string;
        readonly url?: string | null;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyErrorLogMutationVariables = 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 UpdateManyErrorLogMutationQuery = {
  readonly update_error_logs?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly context?: Record<string, any> | null;
      readonly correlation_id?: string | null;
      readonly created_at?: string | null;
      readonly domain?: string | null;
      readonly environment: string;
      readonly error_hash?: string | null;
      readonly error_pattern?: string | null;
      readonly error_type: any;
      readonly frequency_data?: Record<string, any> | null;
      readonly github_repo?: string | null;
      readonly id: string;
      readonly is_new_pattern?: boolean | null;
      readonly message: string;
      readonly metadata?: Record<string, any> | null;
      readonly related_errors?: Record<string, any> | null;
      readonly request_id?: string | null;
      readonly service_name: string;
      readonly severity: any;
      readonly stack_trace?: string | null;
      readonly user_id?: string | null;
    }>;
  } | null;
};

export type UpdateOneErrorLogMutationVariables = 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 UpdateOneErrorLogMutationQuery = {
  readonly update_error_logs_by_pk?: {
    readonly context?: Record<string, any> | null;
    readonly correlation_id?: string | null;
    readonly created_at?: string | null;
    readonly domain?: string | null;
    readonly environment: string;
    readonly error_hash?: string | null;
    readonly error_pattern?: string | null;
    readonly error_type: any;
    readonly frequency_data?: Record<string, any> | null;
    readonly github_repo?: string | null;
    readonly id: string;
    readonly is_new_pattern?: boolean | null;
    readonly message: string;
    readonly metadata?: Record<string, any> | null;
    readonly related_errors?: Record<string, any> | null;
    readonly request_id?: string | null;
    readonly service_name: string;
    readonly severity: any;
    readonly stack_trace?: string | null;
    readonly user_id?: string | null;
  } | null;
};

export type UpdateManyErrorLogsManyMutationVariables = Exact<{
  updates: ReadonlyArray<ErrorLogsUpdates> | ErrorLogsUpdates;
}>;

export type UpdateManyErrorLogsManyMutationQuery = {
  readonly update_error_logs_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly context?: Record<string, any> | null;
      readonly correlation_id?: string | null;
      readonly created_at?: string | null;
      readonly domain?: string | null;
      readonly environment: string;
      readonly error_hash?: string | null;
      readonly error_pattern?: string | null;
      readonly error_type: any;
      readonly frequency_data?: Record<string, any> | null;
      readonly github_repo?: string | null;
      readonly id: string;
      readonly is_new_pattern?: boolean | null;
      readonly message: string;
      readonly metadata?: Record<string, any> | null;
      readonly related_errors?: Record<string, any> | null;
      readonly request_id?: string | null;
      readonly service_name: string;
      readonly severity: any;
      readonly stack_trace?: string | null;
      readonly user_id?: string | null;
    }>;
  } | null> | null;
};

export type UpdateManyFeatureRequestMutationVariables = Exact<{
  _inc?: InputMaybe<FeatureRequestsIncInput>;
  _set?: InputMaybe<FeatureRequestsSetInput>;
  where: FeatureRequestsBoolExp;
}>;

export type UpdateManyFeatureRequestMutationQuery = {
  readonly update_feature_requests?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly downvotes?: number | null;
      readonly engagement_score?: number | null;
      readonly id: string;
      readonly priority_score?: number | null;
      readonly status: string;
      readonly title: string;
      readonly updated_at?: string | null;
      readonly upvotes?: number | null;
      readonly feature_votes: ReadonlyArray<{
        readonly created_at?: string | null;
        readonly feature_id: string;
        readonly feedback?: string | null;
        readonly id: string;
        readonly updated_at?: string | null;
        readonly user_id: string;
        readonly vote_type: any;
      }>;
    }>;
  } | null;
};

export type UpdateOneFeatureRequestMutationVariables = Exact<{
  _inc?: InputMaybe<FeatureRequestsIncInput>;
  _set?: InputMaybe<FeatureRequestsSetInput>;
  pk_columns: FeatureRequestsPkColumnsInput;
}>;

export type UpdateOneFeatureRequestMutationQuery = {
  readonly update_feature_requests_by_pk?: {
    readonly created_at?: string | null;
    readonly description?: string | null;
    readonly downvotes?: number | null;
    readonly engagement_score?: number | null;
    readonly id: string;
    readonly priority_score?: number | null;
    readonly status: string;
    readonly title: string;
    readonly updated_at?: string | null;
    readonly upvotes?: number | null;
    readonly feature_votes: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly feature_id: string;
      readonly feedback?: string | null;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly vote_type: any;
    }>;
  } | null;
};

export type UpdateManyFeatureRequestsManyMutationVariables = Exact<{
  updates: ReadonlyArray<FeatureRequestsUpdates> | FeatureRequestsUpdates;
}>;

export type UpdateManyFeatureRequestsManyMutationQuery = {
  readonly update_feature_requests_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly downvotes?: number | null;
      readonly engagement_score?: number | null;
      readonly id: string;
      readonly priority_score?: number | null;
      readonly status: string;
      readonly title: string;
      readonly updated_at?: string | null;
      readonly upvotes?: number | null;
      readonly feature_votes: ReadonlyArray<{
        readonly created_at?: string | null;
        readonly feature_id: string;
        readonly feedback?: string | null;
        readonly id: string;
        readonly updated_at?: string | null;
        readonly user_id: string;
        readonly vote_type: any;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyFeatureVoteMutationVariables = Exact<{
  _inc?: InputMaybe<FeatureVotesIncInput>;
  _set?: InputMaybe<FeatureVotesSetInput>;
  where: FeatureVotesBoolExp;
}>;

export type UpdateManyFeatureVoteMutationQuery = {
  readonly update_feature_votes?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly feature_id: string;
      readonly feedback?: string | null;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly vote_type: any;
      readonly feature_request: {
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly downvotes?: number | null;
        readonly engagement_score?: number | null;
        readonly id: string;
        readonly priority_score?: number | null;
        readonly status: string;
        readonly title: string;
        readonly updated_at?: string | null;
        readonly upvotes?: number | null;
      };
    }>;
  } | null;
};

export type UpdateOneFeatureVoteMutationVariables = Exact<{
  _inc?: InputMaybe<FeatureVotesIncInput>;
  _set?: InputMaybe<FeatureVotesSetInput>;
  pk_columns: FeatureVotesPkColumnsInput;
}>;

export type UpdateOneFeatureVoteMutationQuery = {
  readonly update_feature_votes_by_pk?: {
    readonly created_at?: string | null;
    readonly feature_id: string;
    readonly feedback?: string | null;
    readonly id: string;
    readonly updated_at?: string | null;
    readonly user_id: string;
    readonly vote_type: any;
    readonly feature_request: {
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly downvotes?: number | null;
      readonly engagement_score?: number | null;
      readonly id: string;
      readonly priority_score?: number | null;
      readonly status: string;
      readonly title: string;
      readonly updated_at?: string | null;
      readonly upvotes?: number | null;
    };
  } | null;
};

export type UpdateManyFeatureVotesManyMutationVariables = Exact<{
  updates: ReadonlyArray<FeatureVotesUpdates> | FeatureVotesUpdates;
}>;

export type UpdateManyFeatureVotesManyMutationQuery = {
  readonly update_feature_votes_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly feature_id: string;
      readonly feedback?: string | null;
      readonly id: string;
      readonly updated_at?: string | null;
      readonly user_id: string;
      readonly vote_type: any;
      readonly feature_request: {
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly downvotes?: number | null;
        readonly engagement_score?: number | null;
        readonly id: string;
        readonly priority_score?: number | null;
        readonly status: string;
        readonly title: string;
        readonly updated_at?: string | null;
        readonly upvotes?: number | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyFeedCategoryMutationVariables = Exact<{
  _inc?: InputMaybe<FeedCategoriesIncInput>;
  _set?: InputMaybe<FeedCategoriesSetInput>;
  where: FeedCategoriesBoolExp;
}>;

export type UpdateManyFeedCategoryMutationQuery = {
  readonly update_feed_categories?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
      readonly category?: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly feed?: {
        readonly created_at: string;
        readonly id: string;
        readonly name?: string | null;
        readonly user_id?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneFeedCategoryMutationVariables = Exact<{
  _inc?: InputMaybe<FeedCategoriesIncInput>;
  _set?: InputMaybe<FeedCategoriesSetInput>;
  pk_columns: FeedCategoriesPkColumnsInput;
}>;

export type UpdateOneFeedCategoryMutationQuery = {
  readonly update_feed_categories_by_pk?: {
    readonly category_id?: number | null;
    readonly created_at: string;
    readonly feed_id?: string | null;
    readonly id: number;
    readonly category?: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly feed?: {
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    } | null;
  } | null;
};

export type UpdateManyFeedCategoriesManyMutationVariables = Exact<{
  updates: ReadonlyArray<FeedCategoriesUpdates> | FeedCategoriesUpdates;
}>;

export type UpdateManyFeedCategoriesManyMutationQuery = {
  readonly update_feed_categories_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
      readonly category?: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly feed?: {
        readonly created_at: string;
        readonly id: string;
        readonly name?: string | null;
        readonly user_id?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyFeedSourceMutationVariables = Exact<{
  _inc?: InputMaybe<FeedSourcesIncInput>;
  _set?: InputMaybe<FeedSourcesSetInput>;
  where: FeedSourcesBoolExp;
}>;

export type UpdateManyFeedSourceMutationQuery = {
  readonly update_feed_sources?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_source_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
      readonly content_source?: {
        readonly company_id?: string | null;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly expected_count?: any | null;
        readonly failed_count?: any | null;
        readonly has_failed?: boolean | null;
        readonly hash?: number | null;
        readonly id: number;
        readonly priority: any;
        readonly refreshed_at?: string | null;
        readonly rss_urls?: ReadonlyArray<string> | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly feed?: {
        readonly created_at: string;
        readonly id: string;
        readonly name?: string | null;
        readonly user_id?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneFeedSourceMutationVariables = Exact<{
  _inc?: InputMaybe<FeedSourcesIncInput>;
  _set?: InputMaybe<FeedSourcesSetInput>;
  pk_columns: FeedSourcesPkColumnsInput;
}>;

export type UpdateOneFeedSourceMutationQuery = {
  readonly update_feed_sources_by_pk?: {
    readonly content_source_id?: number | null;
    readonly created_at: string;
    readonly feed_id?: string | null;
    readonly id: number;
    readonly content_source?: {
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly feed?: {
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    } | null;
  } | null;
};

export type UpdateManyFeedSourcesManyMutationVariables = Exact<{
  updates: ReadonlyArray<FeedSourcesUpdates> | FeedSourcesUpdates;
}>;

export type UpdateManyFeedSourcesManyMutationQuery = {
  readonly update_feed_sources_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_source_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
      readonly content_source?: {
        readonly company_id?: string | null;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly expected_count?: any | null;
        readonly failed_count?: any | null;
        readonly has_failed?: boolean | null;
        readonly hash?: number | null;
        readonly id: number;
        readonly priority: any;
        readonly refreshed_at?: string | null;
        readonly rss_urls?: ReadonlyArray<string> | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly feed?: {
        readonly created_at: string;
        readonly id: string;
        readonly name?: string | null;
        readonly user_id?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyFeedbackMutationVariables = Exact<{
  _inc?: InputMaybe<FeedbacksIncInput>;
  _set?: InputMaybe<FeedbacksSetInput>;
  where: FeedbacksBoolExp;
}>;

export type UpdateManyFeedbackMutationQuery = {
  readonly update_feedbacks?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at: string;
      readonly device_info?: string | null;
      readonly feedback_status?: any | null;
      readonly feedback_type?: any | null;
      readonly id: number;
      readonly message: string;
      readonly page_identifier: string;
      readonly rating?: number | null;
      readonly resolution_comment?: string | null;
      readonly updated_at: string;
      readonly user_id?: string | null;
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneFeedbackMutationVariables = Exact<{
  _inc?: InputMaybe<FeedbacksIncInput>;
  _set?: InputMaybe<FeedbacksSetInput>;
  pk_columns: FeedbacksPkColumnsInput;
}>;

export type UpdateOneFeedbackMutationQuery = {
  readonly update_feedbacks_by_pk?: {
    readonly created_at: string;
    readonly device_info?: string | null;
    readonly feedback_status?: any | null;
    readonly feedback_type?: any | null;
    readonly id: number;
    readonly message: string;
    readonly page_identifier: string;
    readonly rating?: number | null;
    readonly resolution_comment?: string | null;
    readonly updated_at: string;
    readonly user_id?: string | null;
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type UpdateManyFeedbacksManyMutationVariables = Exact<{
  updates: ReadonlyArray<FeedbacksUpdates> | FeedbacksUpdates;
}>;

export type UpdateManyFeedbacksManyMutationQuery = {
  readonly update_feedbacks_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at: string;
      readonly device_info?: string | null;
      readonly feedback_status?: any | null;
      readonly feedback_type?: any | null;
      readonly id: number;
      readonly message: string;
      readonly page_identifier: string;
      readonly rating?: number | null;
      readonly resolution_comment?: string | null;
      readonly updated_at: string;
      readonly user_id?: string | null;
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyFeedMutationVariables = Exact<{
  _set?: InputMaybe<FeedsSetInput>;
  where: FeedsBoolExp;
}>;

export type UpdateManyFeedMutationQuery = {
  readonly update_feeds?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
      readonly feed_categories: ReadonlyArray<{
        readonly category_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly feed_sources: ReadonlyArray<{
        readonly content_source_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneFeedMutationVariables = Exact<{
  _set?: InputMaybe<FeedsSetInput>;
  pk_columns: FeedsPkColumnsInput;
}>;

export type UpdateOneFeedMutationQuery = {
  readonly update_feeds_by_pk?: {
    readonly created_at: string;
    readonly id: string;
    readonly name?: string | null;
    readonly user_id?: string | null;
    readonly feed_categories: ReadonlyArray<{
      readonly category_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly feed_sources: ReadonlyArray<{
      readonly content_source_id?: number | null;
      readonly created_at: string;
      readonly feed_id?: string | null;
      readonly id: number;
    }>;
    readonly user_profile?: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    } | null;
  } | null;
};

export type UpdateManyFeedsManyMutationVariables = Exact<{
  updates: ReadonlyArray<FeedsUpdates> | FeedsUpdates;
}>;

export type UpdateManyFeedsManyMutationQuery = {
  readonly update_feeds_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
      readonly feed_categories: ReadonlyArray<{
        readonly category_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly feed_sources: ReadonlyArray<{
        readonly content_source_id?: number | null;
        readonly created_at: string;
        readonly feed_id?: string | null;
        readonly id: number;
      }>;
      readonly user_profile?: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyFollowMutationVariables = Exact<{
  _set?: InputMaybe<FollowsSetInput>;
  where: FollowsBoolExp;
}>;

export type UpdateManyFollowMutationQuery = {
  readonly update_follows?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly followed_entity: any;
      readonly followed_id: string;
      readonly id: string;
      readonly user_id: string;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneFollowMutationVariables = Exact<{
  _set?: InputMaybe<FollowsSetInput>;
  pk_columns: FollowsPkColumnsInput;
}>;

export type UpdateOneFollowMutationQuery = {
  readonly update_follows_by_pk?: {
    readonly created_at?: string | null;
    readonly followed_entity: any;
    readonly followed_id: string;
    readonly id: string;
    readonly user_id: string;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type UpdateManyFollowsManyMutationVariables = Exact<{
  updates: ReadonlyArray<FollowsUpdates> | FollowsUpdates;
}>;

export type UpdateManyFollowsManyMutationQuery = {
  readonly update_follows_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly followed_entity: any;
      readonly followed_id: string;
      readonly id: string;
      readonly user_id: string;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyMetricDefinitionMutationVariables = Exact<{
  _inc?: InputMaybe<MetricDefinitionsIncInput>;
  _set?: InputMaybe<MetricDefinitionsSetInput>;
  where: MetricDefinitionsBoolExp;
}>;

export type UpdateManyMetricDefinitionMutationQuery = {
  readonly update_metric_definitions?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category?: string | null;
      readonly description?: string | null;
      readonly id: number;
      readonly is_dimensional?: boolean | null;
      readonly name: string;
      readonly type: string;
      readonly unit?: string | null;
      readonly company_metrics: ReadonlyArray<{
        readonly company_id: string;
        readonly crawl_id: string;
        readonly id: number;
        readonly metric_id?: number | null;
        readonly timestamp: string;
        readonly value: Record<string, any>;
      }>;
      readonly spider_metrics: ReadonlyArray<{
        readonly crawl_id: string;
        readonly id: number;
        readonly metric_id?: number | null;
        readonly timestamp: string;
        readonly value: Record<string, any>;
      }>;
    }>;
  } | null;
};

export type UpdateOneMetricDefinitionMutationVariables = Exact<{
  _inc?: InputMaybe<MetricDefinitionsIncInput>;
  _set?: InputMaybe<MetricDefinitionsSetInput>;
  pk_columns: MetricDefinitionsPkColumnsInput;
}>;

export type UpdateOneMetricDefinitionMutationQuery = {
  readonly update_metric_definitions_by_pk?: {
    readonly category?: string | null;
    readonly description?: string | null;
    readonly id: number;
    readonly is_dimensional?: boolean | null;
    readonly name: string;
    readonly type: string;
    readonly unit?: string | null;
    readonly company_metrics: ReadonlyArray<{
      readonly company_id: string;
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
    }>;
    readonly spider_metrics: ReadonlyArray<{
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
    }>;
  } | null;
};

export type UpdateManyMetricDefinitionsManyMutationVariables = Exact<{
  updates: ReadonlyArray<MetricDefinitionsUpdates> | MetricDefinitionsUpdates;
}>;

export type UpdateManyMetricDefinitionsManyMutationQuery = {
  readonly update_metric_definitions_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly category?: string | null;
      readonly description?: string | null;
      readonly id: number;
      readonly is_dimensional?: boolean | null;
      readonly name: string;
      readonly type: string;
      readonly unit?: string | null;
      readonly company_metrics: ReadonlyArray<{
        readonly company_id: string;
        readonly crawl_id: string;
        readonly id: number;
        readonly metric_id?: number | null;
        readonly timestamp: string;
        readonly value: Record<string, any>;
      }>;
      readonly spider_metrics: ReadonlyArray<{
        readonly crawl_id: string;
        readonly id: number;
        readonly metric_id?: number | null;
        readonly timestamp: string;
        readonly value: Record<string, any>;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyNewsMutationVariables = 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 UpdateManyNewsMutationQuery = {
  readonly update_news?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
      readonly category?: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly content_source?: {
        readonly company_id?: string | null;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly expected_count?: any | null;
        readonly failed_count?: any | null;
        readonly has_failed?: boolean | null;
        readonly hash?: number | null;
        readonly id: number;
        readonly priority: any;
        readonly refreshed_at?: string | null;
        readonly rss_urls?: ReadonlyArray<string> | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly news_summaries: ReadonlyArray<{
        readonly complexity_level?: any | null;
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly id: string;
        readonly is_current?: boolean | null;
        readonly news_id: string;
        readonly summary?: string | null;
        readonly updated_at?: string | null;
        readonly version: number;
      }>;
    }>;
  } | null;
};

export type UpdateOneNewsMutationVariables = 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 UpdateOneNewsMutationQuery = {
  readonly update_news_by_pk?: {
    readonly author?: string | null;
    readonly body?: string | null;
    readonly category_id?: number | null;
    readonly company_id?: string | null;
    readonly content_source_id?: number | null;
    readonly content_status: any;
    readonly created_at: string;
    readonly description?: string | null;
    readonly failed_count?: any | null;
    readonly featured_image?: string | null;
    readonly has_summary: boolean;
    readonly hash?: number | null;
    readonly id: string;
    readonly keywords?: Record<string, any> | null;
    readonly published_at?: string | null;
    readonly scrape_frequency: any;
    readonly scraped_at?: string | null;
    readonly title?: string | null;
    readonly updated_at: string;
    readonly url: string;
    readonly category?: {
      readonly body?: string | null;
      readonly created_at: string;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly company?: {
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly content_source?: {
      readonly company_id?: string | null;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly expected_count?: any | null;
      readonly failed_count?: any | null;
      readonly has_failed?: boolean | null;
      readonly hash?: number | null;
      readonly id: number;
      readonly priority: any;
      readonly refreshed_at?: string | null;
      readonly rss_urls?: ReadonlyArray<string> | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    } | null;
    readonly news_summaries: ReadonlyArray<{
      readonly complexity_level?: any | null;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: string;
      readonly is_current?: boolean | null;
      readonly news_id: string;
      readonly summary?: string | null;
      readonly updated_at?: string | null;
      readonly version: number;
    }>;
  } | null;
};

export type UpdateManyNewsManyMutationVariables = Exact<{
  updates: ReadonlyArray<NewsUpdates> | NewsUpdates;
}>;

export type UpdateManyNewsManyMutationQuery = {
  readonly update_news_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
      readonly category?: {
        readonly body?: string | null;
        readonly created_at: string;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly company?: {
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly content_source?: {
        readonly company_id?: string | null;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly expected_count?: any | null;
        readonly failed_count?: any | null;
        readonly has_failed?: boolean | null;
        readonly hash?: number | null;
        readonly id: number;
        readonly priority: any;
        readonly refreshed_at?: string | null;
        readonly rss_urls?: ReadonlyArray<string> | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      } | null;
      readonly news_summaries: ReadonlyArray<{
        readonly complexity_level?: any | null;
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly id: string;
        readonly is_current?: boolean | null;
        readonly news_id: string;
        readonly summary?: string | null;
        readonly updated_at?: string | null;
        readonly version: number;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyNewsSummaryMutationVariables = Exact<{
  _inc?: InputMaybe<NewsSummariesIncInput>;
  _set?: InputMaybe<NewsSummariesSetInput>;
  where: NewsSummariesBoolExp;
}>;

export type UpdateManyNewsSummaryMutationQuery = {
  readonly update_news_summaries?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly complexity_level?: any | null;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: string;
      readonly is_current?: boolean | null;
      readonly news_id: string;
      readonly summary?: string | null;
      readonly updated_at?: string | null;
      readonly version: number;
      readonly news: {
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      };
    }>;
  } | null;
};

export type UpdateOneNewsSummaryMutationVariables = Exact<{
  _inc?: InputMaybe<NewsSummariesIncInput>;
  _set?: InputMaybe<NewsSummariesSetInput>;
  pk_columns: NewsSummariesPkColumnsInput;
}>;

export type UpdateOneNewsSummaryMutationQuery = {
  readonly update_news_summaries_by_pk?: {
    readonly complexity_level?: any | null;
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly id: string;
    readonly is_current?: boolean | null;
    readonly news_id: string;
    readonly summary?: string | null;
    readonly updated_at?: string | null;
    readonly version: number;
    readonly news: {
      readonly author?: string | null;
      readonly body?: string | null;
      readonly category_id?: number | null;
      readonly company_id?: string | null;
      readonly content_source_id?: number | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly featured_image?: string | null;
      readonly has_summary: boolean;
      readonly hash?: number | null;
      readonly id: string;
      readonly keywords?: Record<string, any> | null;
      readonly published_at?: string | null;
      readonly scrape_frequency: any;
      readonly scraped_at?: string | null;
      readonly title?: string | null;
      readonly updated_at: string;
      readonly url: string;
    };
  } | null;
};

export type UpdateManyNewsSummariesManyMutationVariables = Exact<{
  updates: ReadonlyArray<NewsSummariesUpdates> | NewsSummariesUpdates;
}>;

export type UpdateManyNewsSummariesManyMutationQuery = {
  readonly update_news_summaries_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly complexity_level?: any | null;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: string;
      readonly is_current?: boolean | null;
      readonly news_id: string;
      readonly summary?: string | null;
      readonly updated_at?: string | null;
      readonly version: number;
      readonly news: {
        readonly author?: string | null;
        readonly body?: string | null;
        readonly category_id?: number | null;
        readonly company_id?: string | null;
        readonly content_source_id?: number | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly featured_image?: string | null;
        readonly has_summary: boolean;
        readonly hash?: number | null;
        readonly id: string;
        readonly keywords?: Record<string, any> | null;
        readonly published_at?: string | null;
        readonly scrape_frequency: any;
        readonly scraped_at?: string | null;
        readonly title?: string | null;
        readonly updated_at: string;
        readonly url: string;
      };
    }>;
  } | null> | null;
};

export type UpdateManyNewsTagMutationVariables = Exact<{
  _inc?: InputMaybe<NewsTagsIncInput>;
  _set?: InputMaybe<NewsTagsSetInput>;
  where: NewsTagsBoolExp;
}>;

export type UpdateManyNewsTagMutationQuery = {
  readonly update_news_tags?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly id: number;
      readonly news_id?: string | null;
      readonly tag_id: number;
      readonly tag: {
        readonly body?: string | null;
        readonly created_at?: string | null;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneNewsTagMutationVariables = Exact<{
  _inc?: InputMaybe<NewsTagsIncInput>;
  _set?: InputMaybe<NewsTagsSetInput>;
  pk_columns: NewsTagsPkColumnsInput;
}>;

export type UpdateOneNewsTagMutationQuery = {
  readonly update_news_tags_by_pk?: {
    readonly id: number;
    readonly news_id?: string | null;
    readonly tag_id: number;
    readonly tag: {
      readonly body?: string | null;
      readonly created_at?: string | null;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
    };
  } | null;
};

export type UpdateManyNewsTagsManyMutationVariables = Exact<{
  updates: ReadonlyArray<NewsTagsUpdates> | NewsTagsUpdates;
}>;

export type UpdateManyNewsTagsManyMutationQuery = {
  readonly update_news_tags_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly id: number;
      readonly news_id?: string | null;
      readonly tag_id: number;
      readonly tag: {
        readonly body?: string | null;
        readonly created_at?: string | null;
        readonly document_id?: string | null;
        readonly id: number;
        readonly locale?: string | null;
        readonly name: string;
        readonly published_at?: string | null;
        readonly updated_at?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyNewsletterMutationVariables = Exact<{
  _set?: InputMaybe<NewslettersSetInput>;
  where: NewslettersBoolExp;
}>;

export type UpdateManyNewsletterMutationQuery = {
  readonly update_newsletters?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly frequency: string;
      readonly generated_content?: string | null;
      readonly id: string;
      readonly start_date: string;
      readonly title: string;
      readonly updated_at?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null;
};

export type UpdateOneNewsletterMutationVariables = Exact<{
  _set?: InputMaybe<NewslettersSetInput>;
  pk_columns: NewslettersPkColumnsInput;
}>;

export type UpdateOneNewsletterMutationQuery = {
  readonly update_newsletters_by_pk?: {
    readonly content_status: any;
    readonly created_at?: string | null;
    readonly end_date: string;
    readonly frequency: string;
    readonly generated_content?: string | null;
    readonly id: string;
    readonly start_date: string;
    readonly title: string;
    readonly updated_at?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
  } | null;
};

export type UpdateManyNewslettersManyMutationVariables = Exact<{
  updates: ReadonlyArray<NewslettersUpdates> | NewslettersUpdates;
}>;

export type UpdateManyNewslettersManyMutationQuery = {
  readonly update_newsletters_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly end_date: string;
      readonly frequency: string;
      readonly generated_content?: string | null;
      readonly id: string;
      readonly start_date: string;
      readonly title: string;
      readonly updated_at?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
    }>;
  } | null> | null;
};

export type UpdateManyPaymentProviderMutationVariables = Exact<{
  _inc?: InputMaybe<PaymentProvidersIncInput>;
  _set?: InputMaybe<PaymentProvidersSetInput>;
  where: PaymentProvidersBoolExp;
}>;

export type UpdateManyPaymentProviderMutationQuery = {
  readonly update_payment_providers?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_active?: boolean | null;
      readonly name: string;
      readonly updated_at?: string | null;
      readonly customer_payments: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      }>;
      readonly customer_subscriptions: ReadonlyArray<{
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
    }>;
  } | null;
};

export type UpdateOnePaymentProviderMutationVariables = Exact<{
  _inc?: InputMaybe<PaymentProvidersIncInput>;
  _set?: InputMaybe<PaymentProvidersSetInput>;
  pk_columns: PaymentProvidersPkColumnsInput;
}>;

export type UpdateOnePaymentProviderMutationQuery = {
  readonly update_payment_providers_by_pk?: {
    readonly created_at?: string | null;
    readonly id: number;
    readonly is_active?: boolean | null;
    readonly name: string;
    readonly updated_at?: string | null;
    readonly customer_payments: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
    readonly customer_subscriptions: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
  } | null;
};

export type UpdateManyPaymentProvidersManyMutationVariables = Exact<{
  updates: ReadonlyArray<PaymentProvidersUpdates> | PaymentProvidersUpdates;
}>;

export type UpdateManyPaymentProvidersManyMutationQuery = {
  readonly update_payment_providers_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_active?: boolean | null;
      readonly name: string;
      readonly updated_at?: string | null;
      readonly customer_payments: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      }>;
      readonly customer_subscriptions: ReadonlyArray<{
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyPlanPermissionMutationVariables = Exact<{
  _inc?: InputMaybe<PlanPermissionsIncInput>;
  _set?: InputMaybe<PlanPermissionsSetInput>;
  where: PlanPermissionsBoolExp;
}>;

export type UpdateManyPlanPermissionMutationQuery = {
  readonly update_plan_permissions?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly feature: string;
      readonly id: number;
      readonly plan: any;
    }>;
  } | null;
};

export type UpdateOnePlanPermissionMutationVariables = Exact<{
  _inc?: InputMaybe<PlanPermissionsIncInput>;
  _set?: InputMaybe<PlanPermissionsSetInput>;
  pk_columns: PlanPermissionsPkColumnsInput;
}>;

export type UpdateOnePlanPermissionMutationQuery = {
  readonly update_plan_permissions_by_pk?: {
    readonly feature: string;
    readonly id: number;
    readonly plan: any;
  } | null;
};

export type UpdateManyPlanPermissionsManyMutationVariables = Exact<{
  updates: ReadonlyArray<PlanPermissionsUpdates> | PlanPermissionsUpdates;
}>;

export type UpdateManyPlanPermissionsManyMutationQuery = {
  readonly update_plan_permissions_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly feature: string;
      readonly id: number;
      readonly plan: any;
    }>;
  } | null> | null;
};

export type UpdateManyRecentErrorMutationVariables = 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 UpdateManyRecentErrorMutationQuery = {
  readonly update_recent_errors?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly error_type?: any | null;
      readonly message?: string | null;
      readonly metadata?: Record<string, any> | null;
      readonly service_name?: string | null;
      readonly severity?: any | null;
    }>;
  } | null;
};

export type UpdateManyRecentErrorsManyMutationVariables = Exact<{
  updates: ReadonlyArray<RecentErrorsUpdates> | RecentErrorsUpdates;
}>;

export type UpdateManyRecentErrorsManyMutationQuery = {
  readonly update_recent_errors_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly error_type?: any | null;
      readonly message?: string | null;
      readonly metadata?: Record<string, any> | null;
      readonly service_name?: string | null;
      readonly severity?: any | null;
    }>;
  } | null> | null;
};

export type UpdateManyReferralMutationVariables = 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 UpdateManyReferralMutationQuery = {
  readonly update_referrals?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly browser?: string | null;
      readonly client_fingerprint?: string | null;
      readonly conversion_value?: number | null;
      readonly converted_at?: string | null;
      readonly country_code?: string | null;
      readonly created_at?: string | null;
      readonly device_type?: string | null;
      readonly id: string;
      readonly ip_address?: any | null;
      readonly is_suspicious?: boolean | null;
      readonly landing_page?: string | null;
      readonly last_failed_attempt?: string | null;
      readonly referral_status?: any | null;
      readonly referrer_code: string;
      readonly region?: string | null;
      readonly security_flags?: Record<string, any> | null;
      readonly user_agent?: string | null;
      readonly utm_campaign?: string | null;
      readonly utm_medium?: string | null;
      readonly utm_source?: string | null;
      readonly validation_attempts?: number | null;
      readonly visitor_id: string;
    }>;
  } | null;
};

export type UpdateOneReferralMutationVariables = 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 UpdateOneReferralMutationQuery = {
  readonly update_referrals_by_pk?: {
    readonly browser?: string | null;
    readonly client_fingerprint?: string | null;
    readonly conversion_value?: number | null;
    readonly converted_at?: string | null;
    readonly country_code?: string | null;
    readonly created_at?: string | null;
    readonly device_type?: string | null;
    readonly id: string;
    readonly ip_address?: any | null;
    readonly is_suspicious?: boolean | null;
    readonly landing_page?: string | null;
    readonly last_failed_attempt?: string | null;
    readonly referral_status?: any | null;
    readonly referrer_code: string;
    readonly region?: string | null;
    readonly security_flags?: Record<string, any> | null;
    readonly user_agent?: string | null;
    readonly utm_campaign?: string | null;
    readonly utm_medium?: string | null;
    readonly utm_source?: string | null;
    readonly validation_attempts?: number | null;
    readonly visitor_id: string;
  } | null;
};

export type UpdateManyReferralsManyMutationVariables = Exact<{
  updates: ReadonlyArray<ReferralsUpdates> | ReferralsUpdates;
}>;

export type UpdateManyReferralsManyMutationQuery = {
  readonly update_referrals_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly browser?: string | null;
      readonly client_fingerprint?: string | null;
      readonly conversion_value?: number | null;
      readonly converted_at?: string | null;
      readonly country_code?: string | null;
      readonly created_at?: string | null;
      readonly device_type?: string | null;
      readonly id: string;
      readonly ip_address?: any | null;
      readonly is_suspicious?: boolean | null;
      readonly landing_page?: string | null;
      readonly last_failed_attempt?: string | null;
      readonly referral_status?: any | null;
      readonly referrer_code: string;
      readonly region?: string | null;
      readonly security_flags?: Record<string, any> | null;
      readonly user_agent?: string | null;
      readonly utm_campaign?: string | null;
      readonly utm_medium?: string | null;
      readonly utm_source?: string | null;
      readonly validation_attempts?: number | null;
      readonly visitor_id: string;
    }>;
  } | null> | null;
};

export type UpdateManyReferrerBlockMutationVariables = Exact<{
  _set?: InputMaybe<ReferrerBlocksSetInput>;
  where: ReferrerBlocksBoolExp;
}>;

export type UpdateManyReferrerBlockMutationQuery = {
  readonly update_referrer_blocks?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly blocked_at?: string | null;
      readonly blocked_by: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_permanent?: boolean | null;
      readonly reason?: string | null;
      readonly referrer_code: string;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type UpdateOneReferrerBlockMutationVariables = Exact<{
  _set?: InputMaybe<ReferrerBlocksSetInput>;
  pk_columns: ReferrerBlocksPkColumnsInput;
}>;

export type UpdateOneReferrerBlockMutationQuery = {
  readonly update_referrer_blocks_by_pk?: {
    readonly blocked_at?: string | null;
    readonly blocked_by: string;
    readonly created_at?: string | null;
    readonly id: string;
    readonly is_permanent?: boolean | null;
    readonly reason?: string | null;
    readonly referrer_code: string;
    readonly updated_at?: string | null;
  } | null;
};

export type UpdateManyReferrerBlocksManyMutationVariables = Exact<{
  updates: ReadonlyArray<ReferrerBlocksUpdates> | ReferrerBlocksUpdates;
}>;

export type UpdateManyReferrerBlocksManyMutationQuery = {
  readonly update_referrer_blocks_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly blocked_at?: string | null;
      readonly blocked_by: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly is_permanent?: boolean | null;
      readonly reason?: string | null;
      readonly referrer_code: string;
      readonly updated_at?: string | null;
    }>;
  } | null> | null;
};

export type UpdateManyResearchMutationVariables = 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 UpdateManyResearchMutationQuery = {
  readonly update_research?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly research_embedding?: {
        readonly chunk: string;
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly embedding_review_id?: number | null;
        readonly id: number;
        readonly is_flagged?: boolean | null;
        readonly research_id: string;
        readonly updated_at: string;
        readonly url?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneResearchMutationVariables = 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 UpdateOneResearchMutationQuery = {
  readonly update_research_by_pk?: {
    readonly abstract?: string | null;
    readonly abstract_url: string;
    readonly affiliations?: Record<string, any> | null;
    readonly authors?: Record<string, any> | null;
    readonly category?: string | null;
    readonly comments?: string | null;
    readonly content_status: any;
    readonly created_at: string;
    readonly doi_url?: string | null;
    readonly figure_count?: any | null;
    readonly has_embedding?: boolean | null;
    readonly id: string;
    readonly is_flagged: boolean;
    readonly keywords?: string | null;
    readonly month?: string | null;
    readonly page_count?: any | null;
    readonly pdf_url?: string | null;
    readonly published_at?: string | null;
    readonly published_in?: string | null;
    readonly summary?: string | null;
    readonly table_count?: any | null;
    readonly title?: string | null;
    readonly updated_at?: string | null;
    readonly version?: any | null;
    readonly year?: string | null;
    readonly content: {
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly hot_score?: any | null;
      readonly id: string;
      readonly rss_url?: string | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly url: string;
    };
    readonly research_embedding?: {
      readonly chunk: string;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly embedding_review_id?: number | null;
      readonly id: number;
      readonly is_flagged?: boolean | null;
      readonly research_id: string;
      readonly updated_at: string;
      readonly url?: string | null;
    } | null;
  } | null;
};

export type UpdateManyResearchEmbeddingMutationVariables = Exact<{
  _inc?: InputMaybe<ResearchEmbeddingsIncInput>;
  _set?: InputMaybe<ResearchEmbeddingsSetInput>;
  where: ResearchEmbeddingsBoolExp;
}>;

export type UpdateManyResearchEmbeddingMutationQuery = {
  readonly update_research_embeddings?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly chunk: string;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly embedding_review_id?: number | null;
      readonly id: number;
      readonly is_flagged?: boolean | null;
      readonly research_id: string;
      readonly updated_at: string;
      readonly url?: string | null;
      readonly embedding_review?: {
        readonly agent_review?: boolean | null;
        readonly created_at: string;
        readonly human_review?: boolean | null;
        readonly id: number;
        readonly notes?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly research: {
        readonly abstract?: string | null;
        readonly abstract_url: string;
        readonly affiliations?: Record<string, any> | null;
        readonly authors?: Record<string, any> | null;
        readonly category?: string | null;
        readonly comments?: string | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly doi_url?: string | null;
        readonly figure_count?: any | null;
        readonly has_embedding?: boolean | null;
        readonly id: string;
        readonly is_flagged: boolean;
        readonly keywords?: string | null;
        readonly month?: string | null;
        readonly page_count?: any | null;
        readonly pdf_url?: string | null;
        readonly published_at?: string | null;
        readonly published_in?: string | null;
        readonly summary?: string | null;
        readonly table_count?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly version?: any | null;
        readonly year?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneResearchEmbeddingMutationVariables = Exact<{
  _inc?: InputMaybe<ResearchEmbeddingsIncInput>;
  _set?: InputMaybe<ResearchEmbeddingsSetInput>;
  pk_columns: ResearchEmbeddingsPkColumnsInput;
}>;

export type UpdateOneResearchEmbeddingMutationQuery = {
  readonly update_research_embeddings_by_pk?: {
    readonly chunk: string;
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly embedding_review_id?: number | null;
    readonly id: number;
    readonly is_flagged?: boolean | null;
    readonly research_id: string;
    readonly updated_at: string;
    readonly url?: string | null;
    readonly embedding_review?: {
      readonly agent_review?: boolean | null;
      readonly created_at: string;
      readonly human_review?: boolean | null;
      readonly id: number;
      readonly notes?: string | null;
      readonly updated_at?: string | null;
    } | null;
    readonly research: {
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
    };
  } | null;
};

export type UpdateManyResearchEmbeddingsManyMutationVariables = Exact<{
  updates: ReadonlyArray<ResearchEmbeddingsUpdates> | ResearchEmbeddingsUpdates;
}>;

export type UpdateManyResearchEmbeddingsManyMutationQuery = {
  readonly update_research_embeddings_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly chunk: string;
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly embedding_review_id?: number | null;
      readonly id: number;
      readonly is_flagged?: boolean | null;
      readonly research_id: string;
      readonly updated_at: string;
      readonly url?: string | null;
      readonly embedding_review?: {
        readonly agent_review?: boolean | null;
        readonly created_at: string;
        readonly human_review?: boolean | null;
        readonly id: number;
        readonly notes?: string | null;
        readonly updated_at?: string | null;
      } | null;
      readonly research: {
        readonly abstract?: string | null;
        readonly abstract_url: string;
        readonly affiliations?: Record<string, any> | null;
        readonly authors?: Record<string, any> | null;
        readonly category?: string | null;
        readonly comments?: string | null;
        readonly content_status: any;
        readonly created_at: string;
        readonly doi_url?: string | null;
        readonly figure_count?: any | null;
        readonly has_embedding?: boolean | null;
        readonly id: string;
        readonly is_flagged: boolean;
        readonly keywords?: string | null;
        readonly month?: string | null;
        readonly page_count?: any | null;
        readonly pdf_url?: string | null;
        readonly published_at?: string | null;
        readonly published_in?: string | null;
        readonly summary?: string | null;
        readonly table_count?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly version?: any | null;
        readonly year?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyResearchManyMutationVariables = Exact<{
  updates: ReadonlyArray<ResearchUpdates> | ResearchUpdates;
}>;

export type UpdateManyResearchManyMutationQuery = {
  readonly update_research_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly abstract?: string | null;
      readonly abstract_url: string;
      readonly affiliations?: Record<string, any> | null;
      readonly authors?: Record<string, any> | null;
      readonly category?: string | null;
      readonly comments?: string | null;
      readonly content_status: any;
      readonly created_at: string;
      readonly doi_url?: string | null;
      readonly figure_count?: any | null;
      readonly has_embedding?: boolean | null;
      readonly id: string;
      readonly is_flagged: boolean;
      readonly keywords?: string | null;
      readonly month?: string | null;
      readonly page_count?: any | null;
      readonly pdf_url?: string | null;
      readonly published_at?: string | null;
      readonly published_in?: string | null;
      readonly summary?: string | null;
      readonly table_count?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly version?: any | null;
      readonly year?: string | null;
      readonly content: {
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly hot_score?: any | null;
        readonly id: string;
        readonly rss_url?: string | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly url: string;
      };
      readonly research_embedding?: {
        readonly chunk: string;
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly embedding_review_id?: number | null;
        readonly id: number;
        readonly is_flagged?: boolean | null;
        readonly research_id: string;
        readonly updated_at: string;
        readonly url?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyResponseMutationVariables = Exact<{
  _inc?: InputMaybe<ResponsesIncInput>;
  _set?: InputMaybe<ResponsesSetInput>;
  where: ResponsesBoolExp;
}>;

export type UpdateManyResponseMutationQuery = {
  readonly update_responses?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly downvotes?: number | null;
      readonly id: number;
      readonly output: string;
      readonly search_id: number;
      readonly upvotes?: number | null;
      readonly search: {
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly id: number;
        readonly input: string;
        readonly tokens_used?: any | null;
        readonly user_ids?: ReadonlyArray<string> | null;
      };
    }>;
  } | null;
};

export type UpdateOneResponseMutationVariables = Exact<{
  _inc?: InputMaybe<ResponsesIncInput>;
  _set?: InputMaybe<ResponsesSetInput>;
  pk_columns: ResponsesPkColumnsInput;
}>;

export type UpdateOneResponseMutationQuery = {
  readonly update_responses_by_pk?: {
    readonly created_at?: string | null;
    readonly downvotes?: number | null;
    readonly id: number;
    readonly output: string;
    readonly search_id: number;
    readonly upvotes?: number | null;
    readonly search: {
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: number;
      readonly input: string;
      readonly tokens_used?: any | null;
      readonly user_ids?: ReadonlyArray<string> | null;
    };
  } | null;
};

export type UpdateManyResponsesManyMutationVariables = Exact<{
  updates: ReadonlyArray<ResponsesUpdates> | ResponsesUpdates;
}>;

export type UpdateManyResponsesManyMutationQuery = {
  readonly update_responses_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly downvotes?: number | null;
      readonly id: number;
      readonly output: string;
      readonly search_id: number;
      readonly upvotes?: number | null;
      readonly search: {
        readonly created_at?: string | null;
        readonly embedding?: any | null;
        readonly id: number;
        readonly input: string;
        readonly tokens_used?: any | null;
        readonly user_ids?: ReadonlyArray<string> | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyRoleHierarchyMutationVariables = Exact<{
  _set?: InputMaybe<RoleHierarchySetInput>;
  where: RoleHierarchyBoolExp;
}>;

export type UpdateManyRoleHierarchyMutationQuery = {
  readonly update_role_hierarchy?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly child_role: any;
      readonly parent_role: any;
    }>;
  } | null;
};

export type UpdateOneRoleHierarchyMutationVariables = Exact<{
  _set?: InputMaybe<RoleHierarchySetInput>;
  pk_columns: RoleHierarchyPkColumnsInput;
}>;

export type UpdateOneRoleHierarchyMutationQuery = {
  readonly update_role_hierarchy_by_pk?: {
    readonly child_role: any;
    readonly parent_role: any;
  } | null;
};

export type UpdateManyRoleHierarchyManyMutationVariables = Exact<{
  updates: ReadonlyArray<RoleHierarchyUpdates> | RoleHierarchyUpdates;
}>;

export type UpdateManyRoleHierarchyManyMutationQuery = {
  readonly update_role_hierarchy_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly child_role: any;
      readonly parent_role: any;
    }>;
  } | null> | null;
};

export type UpdateManyRolePermissionMutationVariables = 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 UpdateManyRolePermissionMutationQuery = {
  readonly update_role_permissions?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly cached_permissions?: Record<string, any> | null;
      readonly conditions?: Record<string, any> | null;
      readonly id: number;
      readonly inherit_from?: ReadonlyArray<any> | null;
      readonly last_updated?: string | null;
      readonly permissions?: Record<string, any> | null;
      readonly role: any;
      readonly table_name: string;
    }>;
  } | null;
};

export type UpdateOneRolePermissionMutationVariables = 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 UpdateOneRolePermissionMutationQuery = {
  readonly update_role_permissions_by_pk?: {
    readonly cached_permissions?: Record<string, any> | null;
    readonly conditions?: Record<string, any> | null;
    readonly id: number;
    readonly inherit_from?: ReadonlyArray<any> | null;
    readonly last_updated?: string | null;
    readonly permissions?: Record<string, any> | null;
    readonly role: any;
    readonly table_name: string;
  } | null;
};

export type UpdateManyRolePermissionsManyMutationVariables = Exact<{
  updates: ReadonlyArray<RolePermissionsUpdates> | RolePermissionsUpdates;
}>;

export type UpdateManyRolePermissionsManyMutationQuery = {
  readonly update_role_permissions_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly cached_permissions?: Record<string, any> | null;
      readonly conditions?: Record<string, any> | null;
      readonly id: number;
      readonly inherit_from?: ReadonlyArray<any> | null;
      readonly last_updated?: string | null;
      readonly permissions?: Record<string, any> | null;
      readonly role: any;
      readonly table_name: string;
    }>;
  } | null> | null;
};

export type UpdateManyRolePermissionsMaterializedMutationVariables = 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 UpdateManyRolePermissionsMaterializedMutationQuery = {
  readonly update_role_permissions_materialized?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly last_updated?: string | null;
      readonly permissions: Record<string, any>;
      readonly role: any;
    }>;
  } | null;
};

export type UpdateOneRolePermissionsMaterializedMutationVariables = 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 UpdateOneRolePermissionsMaterializedMutationQuery = {
  readonly update_role_permissions_materialized_by_pk?: {
    readonly last_updated?: string | null;
    readonly permissions: Record<string, any>;
    readonly role: any;
  } | null;
};

export type UpdateManyRolePermissionsMaterializedManyMutationVariables = Exact<{
  updates:
    | ReadonlyArray<RolePermissionsMaterializedUpdates>
    | RolePermissionsMaterializedUpdates;
}>;

export type UpdateManyRolePermissionsMaterializedManyMutationQuery = {
  readonly update_role_permissions_materialized_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly last_updated?: string | null;
      readonly permissions: Record<string, any>;
      readonly role: any;
    }>;
  } | null> | null;
};

export type UpdateManyScoringWeightMutationVariables = Exact<{
  _inc?: InputMaybe<ScoringWeightsIncInput>;
  _set?: InputMaybe<ScoringWeightsSetInput>;
  where: ScoringWeightsBoolExp;
}>;

export type UpdateManyScoringWeightMutationQuery = {
  readonly update_scoring_weights?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly description?: string | null;
      readonly id: string;
      readonly name: string;
      readonly updated_at?: string | null;
      readonly weight: any;
    }>;
  } | null;
};

export type UpdateOneScoringWeightMutationVariables = Exact<{
  _inc?: InputMaybe<ScoringWeightsIncInput>;
  _set?: InputMaybe<ScoringWeightsSetInput>;
  pk_columns: ScoringWeightsPkColumnsInput;
}>;

export type UpdateOneScoringWeightMutationQuery = {
  readonly update_scoring_weights_by_pk?: {
    readonly description?: string | null;
    readonly id: string;
    readonly name: string;
    readonly updated_at?: string | null;
    readonly weight: any;
  } | null;
};

export type UpdateManyScoringWeightsManyMutationVariables = Exact<{
  updates: ReadonlyArray<ScoringWeightsUpdates> | ScoringWeightsUpdates;
}>;

export type UpdateManyScoringWeightsManyMutationQuery = {
  readonly update_scoring_weights_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly description?: string | null;
      readonly id: string;
      readonly name: string;
      readonly updated_at?: string | null;
      readonly weight: any;
    }>;
  } | null> | null;
};

export type UpdateManySearchMutationVariables = Exact<{
  _inc?: InputMaybe<SearchesIncInput>;
  _set?: InputMaybe<SearchesSetInput>;
  where: SearchesBoolExp;
}>;

export type UpdateManySearchMutationQuery = {
  readonly update_searches?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: number;
      readonly input: string;
      readonly tokens_used?: any | null;
      readonly user_ids?: ReadonlyArray<string> | null;
      readonly responses: ReadonlyArray<{
        readonly created_at?: string | null;
        readonly downvotes?: number | null;
        readonly id: number;
        readonly output: string;
        readonly search_id: number;
        readonly upvotes?: number | null;
      }>;
    }>;
  } | null;
};

export type UpdateOneSearchMutationVariables = Exact<{
  _inc?: InputMaybe<SearchesIncInput>;
  _set?: InputMaybe<SearchesSetInput>;
  pk_columns: SearchesPkColumnsInput;
}>;

export type UpdateOneSearchMutationQuery = {
  readonly update_searches_by_pk?: {
    readonly created_at?: string | null;
    readonly embedding?: any | null;
    readonly id: number;
    readonly input: string;
    readonly tokens_used?: any | null;
    readonly user_ids?: ReadonlyArray<string> | null;
    readonly responses: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly downvotes?: number | null;
      readonly id: number;
      readonly output: string;
      readonly search_id: number;
      readonly upvotes?: number | null;
    }>;
  } | null;
};

export type UpdateManySearchesManyMutationVariables = Exact<{
  updates: ReadonlyArray<SearchesUpdates> | SearchesUpdates;
}>;

export type UpdateManySearchesManyMutationQuery = {
  readonly update_searches_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly embedding?: any | null;
      readonly id: number;
      readonly input: string;
      readonly tokens_used?: any | null;
      readonly user_ids?: ReadonlyArray<string> | null;
      readonly responses: ReadonlyArray<{
        readonly created_at?: string | null;
        readonly downvotes?: number | null;
        readonly id: number;
        readonly output: string;
        readonly search_id: number;
        readonly upvotes?: number | null;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManySocialMediaMutationVariables = Exact<{
  _inc?: InputMaybe<SocialMediaIncInput>;
  _set?: InputMaybe<SocialMediaSetInput>;
  where: SocialMediaBoolExp;
}>;

export type UpdateManySocialMediaMutationQuery = {
  readonly update_social_media?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly facebook_url?: string | null;
      readonly id: number;
      readonly instagram_url?: string | null;
      readonly linkedin_url?: string | null;
      readonly twitter_url?: string | null;
      readonly updated_at?: string | null;
      readonly youtube_url?: string | null;
      readonly companies: ReadonlyArray<{
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
    }>;
  } | null;
};

export type UpdateOneSocialMediaMutationVariables = Exact<{
  _inc?: InputMaybe<SocialMediaIncInput>;
  _set?: InputMaybe<SocialMediaSetInput>;
  pk_columns: SocialMediaPkColumnsInput;
}>;

export type UpdateOneSocialMediaMutationQuery = {
  readonly update_social_media_by_pk?: {
    readonly created_at?: string | null;
    readonly facebook_url?: string | null;
    readonly id: number;
    readonly instagram_url?: string | null;
    readonly linkedin_url?: string | null;
    readonly twitter_url?: string | null;
    readonly updated_at?: string | null;
    readonly youtube_url?: string | null;
    readonly companies: ReadonlyArray<{
      readonly category?: string | null;
      readonly category_id?: number | null;
      readonly content_status: any;
      readonly created_at?: string | null;
      readonly description?: string | null;
      readonly failed_count?: any | null;
      readonly founding_year?: any | null;
      readonly id: string;
      readonly is_english?: boolean | null;
      readonly is_government?: boolean | null;
      readonly keywords?: Record<string, any> | null;
      readonly logo_url?: string | null;
      readonly name?: string | null;
      readonly scrape_frequency?: any | null;
      readonly scrape_rating?: any | null;
      readonly scraped_at?: string | null;
      readonly social_media_id?: number | null;
      readonly updated_at?: string | null;
      readonly url: string;
    }>;
  } | null;
};

export type UpdateManySocialMediaManyMutationVariables = Exact<{
  updates: ReadonlyArray<SocialMediaUpdates> | SocialMediaUpdates;
}>;

export type UpdateManySocialMediaManyMutationQuery = {
  readonly update_social_media_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly facebook_url?: string | null;
      readonly id: number;
      readonly instagram_url?: string | null;
      readonly linkedin_url?: string | null;
      readonly twitter_url?: string | null;
      readonly updated_at?: string | null;
      readonly youtube_url?: string | null;
      readonly companies: ReadonlyArray<{
        readonly category?: string | null;
        readonly category_id?: number | null;
        readonly content_status: any;
        readonly created_at?: string | null;
        readonly description?: string | null;
        readonly failed_count?: any | null;
        readonly founding_year?: any | null;
        readonly id: string;
        readonly is_english?: boolean | null;
        readonly is_government?: boolean | null;
        readonly keywords?: Record<string, any> | null;
        readonly logo_url?: string | null;
        readonly name?: string | null;
        readonly scrape_frequency?: any | null;
        readonly scrape_rating?: any | null;
        readonly scraped_at?: string | null;
        readonly social_media_id?: number | null;
        readonly updated_at?: string | null;
        readonly url: string;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManySpiderMetricMutationVariables = 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 UpdateManySpiderMetricMutationQuery = {
  readonly update_spider_metrics?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
      readonly metric_definition?: {
        readonly category?: string | null;
        readonly description?: string | null;
        readonly id: number;
        readonly is_dimensional?: boolean | null;
        readonly name: string;
        readonly type: string;
        readonly unit?: string | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneSpiderMetricMutationVariables = 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 UpdateOneSpiderMetricMutationQuery = {
  readonly update_spider_metrics_by_pk?: {
    readonly crawl_id: string;
    readonly id: number;
    readonly metric_id?: number | null;
    readonly timestamp: string;
    readonly value: Record<string, any>;
    readonly metric_definition?: {
      readonly category?: string | null;
      readonly description?: string | null;
      readonly id: number;
      readonly is_dimensional?: boolean | null;
      readonly name: string;
      readonly type: string;
      readonly unit?: string | null;
    } | null;
  } | null;
};

export type UpdateManySpiderMetricsManyMutationVariables = Exact<{
  updates: ReadonlyArray<SpiderMetricsUpdates> | SpiderMetricsUpdates;
}>;

export type UpdateManySpiderMetricsManyMutationQuery = {
  readonly update_spider_metrics_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly crawl_id: string;
      readonly id: number;
      readonly metric_id?: number | null;
      readonly timestamp: string;
      readonly value: Record<string, any>;
      readonly metric_definition?: {
        readonly category?: string | null;
        readonly description?: string | null;
        readonly id: number;
        readonly is_dimensional?: boolean | null;
        readonly name: string;
        readonly type: string;
        readonly unit?: string | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyStrapiMigrationMutationVariables = Exact<{
  _inc?: InputMaybe<StrapiMigrationsIncInput>;
  _set?: InputMaybe<StrapiMigrationsSetInput>;
  where: StrapiMigrationsBoolExp;
}>;

export type UpdateManyStrapiMigrationMutationQuery = {
  readonly update_strapi_migrations?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly id: number;
      readonly name?: string | null;
      readonly time?: string | null;
    }>;
  } | null;
};

export type UpdateOneStrapiMigrationMutationVariables = Exact<{
  _inc?: InputMaybe<StrapiMigrationsIncInput>;
  _set?: InputMaybe<StrapiMigrationsSetInput>;
  pk_columns: StrapiMigrationsPkColumnsInput;
}>;

export type UpdateOneStrapiMigrationMutationQuery = {
  readonly update_strapi_migrations_by_pk?: {
    readonly id: number;
    readonly name?: string | null;
    readonly time?: string | null;
  } | null;
};

export type UpdateManyStrapiMigrationsInternalMutationVariables = Exact<{
  _inc?: InputMaybe<StrapiMigrationsInternalIncInput>;
  _set?: InputMaybe<StrapiMigrationsInternalSetInput>;
  where: StrapiMigrationsInternalBoolExp;
}>;

export type UpdateManyStrapiMigrationsInternalMutationQuery = {
  readonly update_strapi_migrations_internal?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly id: number;
      readonly name?: string | null;
      readonly time?: string | null;
    }>;
  } | null;
};

export type UpdateOneStrapiMigrationsInternalMutationVariables = Exact<{
  _inc?: InputMaybe<StrapiMigrationsInternalIncInput>;
  _set?: InputMaybe<StrapiMigrationsInternalSetInput>;
  pk_columns: StrapiMigrationsInternalPkColumnsInput;
}>;

export type UpdateOneStrapiMigrationsInternalMutationQuery = {
  readonly update_strapi_migrations_internal_by_pk?: {
    readonly id: number;
    readonly name?: string | null;
    readonly time?: string | null;
  } | null;
};

export type UpdateManyStrapiMigrationsInternalManyMutationVariables = Exact<{
  updates:
    | ReadonlyArray<StrapiMigrationsInternalUpdates>
    | StrapiMigrationsInternalUpdates;
}>;

export type UpdateManyStrapiMigrationsInternalManyMutationQuery = {
  readonly update_strapi_migrations_internal_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly id: number;
      readonly name?: string | null;
      readonly time?: string | null;
    }>;
  } | null> | null;
};

export type UpdateManyStrapiMigrationsManyMutationVariables = Exact<{
  updates: ReadonlyArray<StrapiMigrationsUpdates> | StrapiMigrationsUpdates;
}>;

export type UpdateManyStrapiMigrationsManyMutationQuery = {
  readonly update_strapi_migrations_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly id: number;
      readonly name?: string | null;
      readonly time?: string | null;
    }>;
  } | null> | null;
};

export type UpdateManyTableMaintenanceLogMutationVariables = Exact<{
  _inc?: InputMaybe<TableMaintenanceLogIncInput>;
  _set?: InputMaybe<TableMaintenanceLogSetInput>;
  where: TableMaintenanceLogBoolExp;
}>;

export type UpdateManyTableMaintenanceLogMutationQuery = {
  readonly update_table_maintenance_log?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly detail?: string | null;
      readonly id: number;
      readonly logged_at?: string | null;
      readonly operation?: string | null;
    }>;
  } | null;
};

export type UpdateOneTableMaintenanceLogMutationVariables = Exact<{
  _inc?: InputMaybe<TableMaintenanceLogIncInput>;
  _set?: InputMaybe<TableMaintenanceLogSetInput>;
  pk_columns: TableMaintenanceLogPkColumnsInput;
}>;

export type UpdateOneTableMaintenanceLogMutationQuery = {
  readonly update_table_maintenance_log_by_pk?: {
    readonly detail?: string | null;
    readonly id: number;
    readonly logged_at?: string | null;
    readonly operation?: string | null;
  } | null;
};

export type UpdateManyTableMaintenanceLogManyMutationVariables = Exact<{
  updates:
    | ReadonlyArray<TableMaintenanceLogUpdates>
    | TableMaintenanceLogUpdates;
}>;

export type UpdateManyTableMaintenanceLogManyMutationQuery = {
  readonly update_table_maintenance_log_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly detail?: string | null;
      readonly id: number;
      readonly logged_at?: string | null;
      readonly operation?: string | null;
    }>;
  } | null> | null;
};

export type UpdateManyTableQueryPerformanceMutationVariables = Exact<{
  _inc?: InputMaybe<TableQueryPerformanceIncInput>;
  _set?: InputMaybe<TableQueryPerformanceSetInput>;
  where: TableQueryPerformanceBoolExp;
}>;

export type UpdateManyTableQueryPerformanceMutationQuery = {
  readonly update_table_query_performance?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly avg_duration?: any | null;
      readonly capture_time?: string | null;
      readonly execution_count?: number | null;
      readonly query?: string | null;
    }>;
  } | null;
};

export type UpdateManyTableQueryPerformanceManyMutationVariables = Exact<{
  updates:
    | ReadonlyArray<TableQueryPerformanceUpdates>
    | TableQueryPerformanceUpdates;
}>;

export type UpdateManyTableQueryPerformanceManyMutationQuery = {
  readonly update_table_query_performance_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly avg_duration?: any | null;
      readonly capture_time?: string | null;
      readonly execution_count?: number | null;
      readonly query?: string | null;
    }>;
  } | null> | null;
};

export type UpdateManyTableSequenceUsageMutationVariables = Exact<{
  _inc?: InputMaybe<TableSequenceUsageIncInput>;
  _set?: InputMaybe<TableSequenceUsageSetInput>;
  where: TableSequenceUsageBoolExp;
}>;

export type UpdateManyTableSequenceUsageMutationQuery = {
  readonly update_table_sequence_usage?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly capture_time?: string | null;
      readonly current_value?: number | null;
      readonly max_value?: number | null;
      readonly sequence_name?: string | null;
    }>;
  } | null;
};

export type UpdateManyTableSequenceUsageManyMutationVariables = Exact<{
  updates: ReadonlyArray<TableSequenceUsageUpdates> | TableSequenceUsageUpdates;
}>;

export type UpdateManyTableSequenceUsageManyMutationQuery = {
  readonly update_table_sequence_usage_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly capture_time?: string | null;
      readonly current_value?: number | null;
      readonly max_value?: number | null;
      readonly sequence_name?: string | null;
    }>;
  } | null> | null;
};

export type UpdateManyTableStatisticMutationVariables = 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 UpdateManyTableStatisticMutationQuery = {
  readonly update_table_statistics?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly buffer_cache_hit_ratio?: any | null;
      readonly capture_time: string;
      readonly dead_tuples?: number | null;
      readonly estimated_bloat_ratio?: any | null;
      readonly index_scan_count?: number | null;
      readonly index_size?: number | null;
      readonly index_usage?: Record<string, any> | null;
      readonly last_analyze?: string | null;
      readonly last_vacuum?: string | null;
      readonly live_tuples?: number | null;
      readonly row_count?: number | null;
      readonly seq_scan_count?: number | null;
      readonly table_name: string;
      readonly table_size?: number | null;
    }>;
  } | null;
};

export type UpdateOneTableStatisticMutationVariables = 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 UpdateOneTableStatisticMutationQuery = {
  readonly update_table_statistics_by_pk?: {
    readonly buffer_cache_hit_ratio?: any | null;
    readonly capture_time: string;
    readonly dead_tuples?: number | null;
    readonly estimated_bloat_ratio?: any | null;
    readonly index_scan_count?: number | null;
    readonly index_size?: number | null;
    readonly index_usage?: Record<string, any> | null;
    readonly last_analyze?: string | null;
    readonly last_vacuum?: string | null;
    readonly live_tuples?: number | null;
    readonly row_count?: number | null;
    readonly seq_scan_count?: number | null;
    readonly table_name: string;
    readonly table_size?: number | null;
  } | null;
};

export type UpdateManyTableStatisticsManyMutationVariables = Exact<{
  updates: ReadonlyArray<TableStatisticsUpdates> | TableStatisticsUpdates;
}>;

export type UpdateManyTableStatisticsManyMutationQuery = {
  readonly update_table_statistics_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly buffer_cache_hit_ratio?: any | null;
      readonly capture_time: string;
      readonly dead_tuples?: number | null;
      readonly estimated_bloat_ratio?: any | null;
      readonly index_scan_count?: number | null;
      readonly index_size?: number | null;
      readonly index_usage?: Record<string, any> | null;
      readonly last_analyze?: string | null;
      readonly last_vacuum?: string | null;
      readonly live_tuples?: number | null;
      readonly row_count?: number | null;
      readonly seq_scan_count?: number | null;
      readonly table_name: string;
      readonly table_size?: number | null;
    }>;
  } | null> | null;
};

export type UpdateManyTagMutationVariables = Exact<{
  _inc?: InputMaybe<TagsIncInput>;
  _set?: InputMaybe<TagsSetInput>;
  where: TagsBoolExp;
}>;

export type UpdateManyTagMutationQuery = {
  readonly update_tags?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly body?: string | null;
      readonly created_at?: string | null;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
      readonly content_tags: ReadonlyArray<{
        readonly content_id: string;
        readonly tag_id: number;
      }>;
      readonly news_tags: ReadonlyArray<{
        readonly id: number;
        readonly news_id?: string | null;
        readonly tag_id: number;
      }>;
    }>;
  } | null;
};

export type UpdateOneTagMutationVariables = Exact<{
  _inc?: InputMaybe<TagsIncInput>;
  _set?: InputMaybe<TagsSetInput>;
  pk_columns: TagsPkColumnsInput;
}>;

export type UpdateOneTagMutationQuery = {
  readonly update_tags_by_pk?: {
    readonly body?: string | null;
    readonly created_at?: string | null;
    readonly document_id?: string | null;
    readonly id: number;
    readonly locale?: string | null;
    readonly name: string;
    readonly published_at?: string | null;
    readonly updated_at?: string | null;
    readonly content_tags: ReadonlyArray<{
      readonly content_id: string;
      readonly tag_id: number;
    }>;
    readonly news_tags: ReadonlyArray<{
      readonly id: number;
      readonly news_id?: string | null;
      readonly tag_id: number;
    }>;
  } | null;
};

export type UpdateManyTagsManyMutationVariables = Exact<{
  updates: ReadonlyArray<TagsUpdates> | TagsUpdates;
}>;

export type UpdateManyTagsManyMutationQuery = {
  readonly update_tags_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly body?: string | null;
      readonly created_at?: string | null;
      readonly document_id?: string | null;
      readonly id: number;
      readonly locale?: string | null;
      readonly name: string;
      readonly published_at?: string | null;
      readonly updated_at?: string | null;
      readonly content_tags: ReadonlyArray<{
        readonly content_id: string;
        readonly tag_id: number;
      }>;
      readonly news_tags: ReadonlyArray<{
        readonly id: number;
        readonly news_id?: string | null;
        readonly tag_id: number;
      }>;
    }>;
  } | null> | null;
};

export type UpdateManyUserMetricMutationVariables = 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 UpdateManyUserMetricMutationQuery = {
  readonly update_user_metrics?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly achievements?: Record<string, any> | null;
      readonly best_streak?: number | null;
      readonly created_at?: string | null;
      readonly current_level?: number | null;
      readonly current_streak?: number | null;
      readonly current_xp?: number | null;
      readonly downvote_count?: number | null;
      readonly id: string;
      readonly interaction_stats?: Record<string, any> | null;
      readonly last_vote_date?: string | null;
      readonly multipliers?: Record<string, any> | null;
      readonly points?: number | null;
      readonly points_breakdown?: Record<string, any> | null;
      readonly titles?: Record<string, any> | null;
      readonly today_vote_count?: number | null;
      readonly total_reading_time?: number | null;
      readonly total_votes?: number | null;
      readonly updated_at?: string | null;
      readonly upvote_count?: number | null;
      readonly user_id: string;
      readonly vote_accuracy?: number | null;
      readonly xp_to_next_level?: number | null;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null;
};

export type UpdateOneUserMetricMutationVariables = 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 UpdateOneUserMetricMutationQuery = {
  readonly update_user_metrics_by_pk?: {
    readonly achievements?: Record<string, any> | null;
    readonly best_streak?: number | null;
    readonly created_at?: string | null;
    readonly current_level?: number | null;
    readonly current_streak?: number | null;
    readonly current_xp?: number | null;
    readonly downvote_count?: number | null;
    readonly id: string;
    readonly interaction_stats?: Record<string, any> | null;
    readonly last_vote_date?: string | null;
    readonly multipliers?: Record<string, any> | null;
    readonly points?: number | null;
    readonly points_breakdown?: Record<string, any> | null;
    readonly titles?: Record<string, any> | null;
    readonly today_vote_count?: number | null;
    readonly total_reading_time?: number | null;
    readonly total_votes?: number | null;
    readonly updated_at?: string | null;
    readonly upvote_count?: number | null;
    readonly user_id: string;
    readonly vote_accuracy?: number | null;
    readonly xp_to_next_level?: number | null;
    readonly user_profile: {
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
    };
  } | null;
};

export type UpdateManyUserMetricsManyMutationVariables = Exact<{
  updates: ReadonlyArray<UserMetricsUpdates> | UserMetricsUpdates;
}>;

export type UpdateManyUserMetricsManyMutationQuery = {
  readonly update_user_metrics_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly achievements?: Record<string, any> | null;
      readonly best_streak?: number | null;
      readonly created_at?: string | null;
      readonly current_level?: number | null;
      readonly current_streak?: number | null;
      readonly current_xp?: number | null;
      readonly downvote_count?: number | null;
      readonly id: string;
      readonly interaction_stats?: Record<string, any> | null;
      readonly last_vote_date?: string | null;
      readonly multipliers?: Record<string, any> | null;
      readonly points?: number | null;
      readonly points_breakdown?: Record<string, any> | null;
      readonly titles?: Record<string, any> | null;
      readonly today_vote_count?: number | null;
      readonly total_reading_time?: number | null;
      readonly total_votes?: number | null;
      readonly updated_at?: string | null;
      readonly upvote_count?: number | null;
      readonly user_id: string;
      readonly vote_accuracy?: number | null;
      readonly xp_to_next_level?: number | null;
      readonly user_profile: {
        readonly avatar?: string | null;
        readonly created_at?: string | null;
        readonly dob?: any | null;
        readonly email: string;
        readonly followed_count?: number | null;
        readonly followers_count?: number | null;
        readonly gender_id?: any | null;
        readonly given_name?: string | null;
        readonly id: string;
        readonly introduction?: string | null;
        readonly is_active?: boolean | null;
        readonly last_seen?: string | null;
        readonly plan?: any | null;
        readonly role: any;
        readonly surname?: string | null;
        readonly updated_at?: string | null;
        readonly username?: string | null;
      };
    }>;
  } | null> | null;
};

export type UpdateManyUserProfileMutationVariables = Exact<{
  _inc?: InputMaybe<UserProfilesIncInput>;
  _set?: InputMaybe<UserProfilesSetInput>;
  where: UserProfilesBoolExp;
}>;

export type UpdateManyUserProfileMutationQuery = {
  readonly update_user_profiles?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly comments: ReadonlyArray<{
        readonly content: string;
        readonly content_id: string;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly id: string;
        readonly parent_comment_id?: string | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly company_employees: ReadonlyArray<{
        readonly access_level: any;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date?: string | null;
        readonly id: string;
        readonly job_description?: string | null;
        readonly role: string;
        readonly start_date?: string | null;
        readonly status?: boolean | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_type?: any | null;
        readonly created_at?: string | null;
        readonly email?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly phone?: string | null;
        readonly privacy_level?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly content_source_visits: ReadonlyArray<{
        readonly content_id: string;
        readonly created_at?: string | null;
        readonly id: string;
        readonly user_id?: string | null;
      }>;
      readonly customer_payments: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      }>;
      readonly customer_subscriptions: ReadonlyArray<{
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly feedbacks: ReadonlyArray<{
        readonly created_at: string;
        readonly device_info?: string | null;
        readonly feedback_status?: any | null;
        readonly feedback_type?: any | null;
        readonly id: number;
        readonly message: string;
        readonly page_identifier: string;
        readonly rating?: number | null;
        readonly resolution_comment?: string | null;
        readonly updated_at: string;
        readonly user_id?: string | null;
      }>;
      readonly feeds: ReadonlyArray<{
        readonly created_at: string;
        readonly id: string;
        readonly name?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly follows: ReadonlyArray<{
        readonly created_at?: string | null;
        readonly followed_entity: any;
        readonly followed_id: string;
        readonly id: string;
        readonly user_id: string;
      }>;
      readonly user_metric?: {
        readonly achievements?: Record<string, any> | null;
        readonly best_streak?: number | null;
        readonly created_at?: string | null;
        readonly current_level?: number | null;
        readonly current_streak?: number | null;
        readonly current_xp?: number | null;
        readonly downvote_count?: number | null;
        readonly id: string;
        readonly interaction_stats?: Record<string, any> | null;
        readonly last_vote_date?: string | null;
        readonly multipliers?: Record<string, any> | null;
        readonly points?: number | null;
        readonly points_breakdown?: Record<string, any> | null;
        readonly titles?: Record<string, any> | null;
        readonly today_vote_count?: number | null;
        readonly total_reading_time?: number | null;
        readonly total_votes?: number | null;
        readonly updated_at?: string | null;
        readonly upvote_count?: number | null;
        readonly user_id: string;
        readonly vote_accuracy?: number | null;
        readonly xp_to_next_level?: number | null;
      } | null;
    }>;
  } | null;
};

export type UpdateOneUserProfileMutationVariables = Exact<{
  _inc?: InputMaybe<UserProfilesIncInput>;
  _set?: InputMaybe<UserProfilesSetInput>;
  pk_columns: UserProfilesPkColumnsInput;
}>;

export type UpdateOneUserProfileMutationQuery = {
  readonly update_user_profiles_by_pk?: {
    readonly avatar?: string | null;
    readonly created_at?: string | null;
    readonly dob?: any | null;
    readonly email: string;
    readonly followed_count?: number | null;
    readonly followers_count?: number | null;
    readonly gender_id?: any | null;
    readonly given_name?: string | null;
    readonly id: string;
    readonly introduction?: string | null;
    readonly is_active?: boolean | null;
    readonly last_seen?: string | null;
    readonly plan?: any | null;
    readonly role: any;
    readonly surname?: string | null;
    readonly updated_at?: string | null;
    readonly username?: string | null;
    readonly addresses: ReadonlyArray<{
      readonly address_type?: any | null;
      readonly city_id: number;
      readonly company_id?: string | null;
      readonly country_id: number;
      readonly created_at?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly name?: string | null;
      readonly street1: string;
      readonly street2?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly comments: ReadonlyArray<{
      readonly content: string;
      readonly content_id: string;
      readonly content_type: any;
      readonly created_at?: string | null;
      readonly id: string;
      readonly parent_comment_id?: string | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly company_employees: ReadonlyArray<{
      readonly access_level: any;
      readonly company_id?: string | null;
      readonly created_at?: string | null;
      readonly end_date?: string | null;
      readonly id: string;
      readonly job_description?: string | null;
      readonly role: string;
      readonly start_date?: string | null;
      readonly status?: boolean | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly contacts: ReadonlyArray<{
      readonly company_id?: string | null;
      readonly contact_type?: any | null;
      readonly created_at?: string | null;
      readonly email?: string | null;
      readonly id: number;
      readonly is_primary?: boolean | null;
      readonly phone?: string | null;
      readonly privacy_level?: any | null;
      readonly title?: string | null;
      readonly updated_at?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly content_source_visits: ReadonlyArray<{
      readonly content_id: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id?: string | null;
    }>;
    readonly customer_payments: ReadonlyArray<{
      readonly acquirer_data?: Record<string, any> | null;
      readonly amount: number;
      readonly amount_refunded?: number | null;
      readonly amount_transferred?: number | null;
      readonly bank?: string | null;
      readonly captured?: boolean | null;
      readonly created_at?: string | null;
      readonly currency: string;
      readonly description?: string | null;
      readonly error_code?: string | null;
      readonly error_description?: string | null;
      readonly error_reason?: string | null;
      readonly error_source?: string | null;
      readonly error_step?: string | null;
      readonly external_order_id?: string | null;
      readonly external_payment_id: string;
      readonly fee?: number | null;
      readonly id: number;
      readonly international?: boolean | null;
      readonly invoice_id?: string | null;
      readonly method?: string | null;
      readonly notes?: Record<string, any> | null;
      readonly order_id?: string | null;
      readonly payment_provider_id: number;
      readonly refund_status?: string | null;
      readonly status: string;
      readonly subscription_id?: number | null;
      readonly tax?: number | null;
      readonly user_id: string;
      readonly vpa?: string | null;
      readonly wallet?: string | null;
    }>;
    readonly customer_subscriptions: ReadonlyArray<{
      readonly auth_attempts?: number | null;
      readonly cancel_at_period_end?: boolean | null;
      readonly cancel_initiated_by?: string | null;
      readonly change_scheduled_at?: string | null;
      readonly charge_at?: string | null;
      readonly created_at?: string | null;
      readonly current_end: string;
      readonly current_start: string;
      readonly customer_notify?: boolean | null;
      readonly end_at?: string | null;
      readonly ended_at?: string | null;
      readonly expire_by?: string | null;
      readonly external_subscription_id: string;
      readonly has_scheduled_changes?: boolean | null;
      readonly id: number;
      readonly notes?: Record<string, any> | null;
      readonly offer_id?: string | null;
      readonly paid_count?: number | null;
      readonly pause_initiated_by?: string | null;
      readonly payment_provider_id: number;
      readonly plan_id: number;
      readonly quantity?: number | null;
      readonly remaining_count?: number | null;
      readonly short_url?: string | null;
      readonly source?: string | null;
      readonly start_at?: string | null;
      readonly status: string;
      readonly total_count?: number | null;
      readonly type?: number | null;
      readonly updated_at?: string | null;
      readonly user_id: string;
    }>;
    readonly feedbacks: ReadonlyArray<{
      readonly created_at: string;
      readonly device_info?: string | null;
      readonly feedback_status?: any | null;
      readonly feedback_type?: any | null;
      readonly id: number;
      readonly message: string;
      readonly page_identifier: string;
      readonly rating?: number | null;
      readonly resolution_comment?: string | null;
      readonly updated_at: string;
      readonly user_id?: string | null;
    }>;
    readonly feeds: ReadonlyArray<{
      readonly created_at: string;
      readonly id: string;
      readonly name?: string | null;
      readonly user_id?: string | null;
    }>;
    readonly follows: ReadonlyArray<{
      readonly created_at?: string | null;
      readonly followed_entity: any;
      readonly followed_id: string;
      readonly id: string;
      readonly user_id: string;
    }>;
    readonly user_metric?: {
      readonly achievements?: Record<string, any> | null;
      readonly best_streak?: number | null;
      readonly created_at?: string | null;
      readonly current_level?: number | null;
      readonly current_streak?: number | null;
      readonly current_xp?: number | null;
      readonly downvote_count?: number | null;
      readonly id: string;
      readonly interaction_stats?: Record<string, any> | null;
      readonly last_vote_date?: string | null;
      readonly multipliers?: Record<string, any> | null;
      readonly points?: number | null;
      readonly points_breakdown?: Record<string, any> | null;
      readonly titles?: Record<string, any> | null;
      readonly today_vote_count?: number | null;
      readonly total_reading_time?: number | null;
      readonly total_votes?: number | null;
      readonly updated_at?: string | null;
      readonly upvote_count?: number | null;
      readonly user_id: string;
      readonly vote_accuracy?: number | null;
      readonly xp_to_next_level?: number | null;
    } | null;
  } | null;
};

export type UpdateManyUserProfilesManyMutationVariables = Exact<{
  updates: ReadonlyArray<UserProfilesUpdates> | UserProfilesUpdates;
}>;

export type UpdateManyUserProfilesManyMutationQuery = {
  readonly update_user_profiles_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly avatar?: string | null;
      readonly created_at?: string | null;
      readonly dob?: any | null;
      readonly email: string;
      readonly followed_count?: number | null;
      readonly followers_count?: number | null;
      readonly gender_id?: any | null;
      readonly given_name?: string | null;
      readonly id: string;
      readonly introduction?: string | null;
      readonly is_active?: boolean | null;
      readonly last_seen?: string | null;
      readonly plan?: any | null;
      readonly role: any;
      readonly surname?: string | null;
      readonly updated_at?: string | null;
      readonly username?: string | null;
      readonly addresses: ReadonlyArray<{
        readonly address_type?: any | null;
        readonly city_id: number;
        readonly company_id?: string | null;
        readonly country_id: number;
        readonly created_at?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly name?: string | null;
        readonly street1: string;
        readonly street2?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly comments: ReadonlyArray<{
        readonly content: string;
        readonly content_id: string;
        readonly content_type: any;
        readonly created_at?: string | null;
        readonly id: string;
        readonly parent_comment_id?: string | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly company_employees: ReadonlyArray<{
        readonly access_level: any;
        readonly company_id?: string | null;
        readonly created_at?: string | null;
        readonly end_date?: string | null;
        readonly id: string;
        readonly job_description?: string | null;
        readonly role: string;
        readonly start_date?: string | null;
        readonly status?: boolean | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly contacts: ReadonlyArray<{
        readonly company_id?: string | null;
        readonly contact_type?: any | null;
        readonly created_at?: string | null;
        readonly email?: string | null;
        readonly id: number;
        readonly is_primary?: boolean | null;
        readonly phone?: string | null;
        readonly privacy_level?: any | null;
        readonly title?: string | null;
        readonly updated_at?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly content_source_visits: ReadonlyArray<{
        readonly content_id: string;
        readonly created_at?: string | null;
        readonly id: string;
        readonly user_id?: string | null;
      }>;
      readonly customer_payments: ReadonlyArray<{
        readonly acquirer_data?: Record<string, any> | null;
        readonly amount: number;
        readonly amount_refunded?: number | null;
        readonly amount_transferred?: number | null;
        readonly bank?: string | null;
        readonly captured?: boolean | null;
        readonly created_at?: string | null;
        readonly currency: string;
        readonly description?: string | null;
        readonly error_code?: string | null;
        readonly error_description?: string | null;
        readonly error_reason?: string | null;
        readonly error_source?: string | null;
        readonly error_step?: string | null;
        readonly external_order_id?: string | null;
        readonly external_payment_id: string;
        readonly fee?: number | null;
        readonly id: number;
        readonly international?: boolean | null;
        readonly invoice_id?: string | null;
        readonly method?: string | null;
        readonly notes?: Record<string, any> | null;
        readonly order_id?: string | null;
        readonly payment_provider_id: number;
        readonly refund_status?: string | null;
        readonly status: string;
        readonly subscription_id?: number | null;
        readonly tax?: number | null;
        readonly user_id: string;
        readonly vpa?: string | null;
        readonly wallet?: string | null;
      }>;
      readonly customer_subscriptions: ReadonlyArray<{
        readonly auth_attempts?: number | null;
        readonly cancel_at_period_end?: boolean | null;
        readonly cancel_initiated_by?: string | null;
        readonly change_scheduled_at?: string | null;
        readonly charge_at?: string | null;
        readonly created_at?: string | null;
        readonly current_end: string;
        readonly current_start: string;
        readonly customer_notify?: boolean | null;
        readonly end_at?: string | null;
        readonly ended_at?: string | null;
        readonly expire_by?: string | null;
        readonly external_subscription_id: string;
        readonly has_scheduled_changes?: boolean | null;
        readonly id: number;
        readonly notes?: Record<string, any> | null;
        readonly offer_id?: string | null;
        readonly paid_count?: number | null;
        readonly pause_initiated_by?: string | null;
        readonly payment_provider_id: number;
        readonly plan_id: number;
        readonly quantity?: number | null;
        readonly remaining_count?: number | null;
        readonly short_url?: string | null;
        readonly source?: string | null;
        readonly start_at?: string | null;
        readonly status: string;
        readonly total_count?: number | null;
        readonly type?: number | null;
        readonly updated_at?: string | null;
        readonly user_id: string;
      }>;
      readonly feedbacks: ReadonlyArray<{
        readonly created_at: string;
        readonly device_info?: string | null;
        readonly feedback_status?: any | null;
        readonly feedback_type?: any | null;
        readonly id: number;
        readonly message: string;
        readonly page_identifier: string;
        readonly rating?: number | null;
        readonly resolution_comment?: string | null;
        readonly updated_at: string;
        readonly user_id?: string | null;
      }>;
      readonly feeds: ReadonlyArray<{
        readonly created_at: string;
        readonly id: string;
        readonly name?: string | null;
        readonly user_id?: string | null;
      }>;
      readonly follows: ReadonlyArray<{
        readonly created_at?: string | null;
        readonly followed_entity: any;
        readonly followed_id: string;
        readonly id: string;
        readonly user_id: string;
      }>;
      readonly user_metric?: {
        readonly achievements?: Record<string, any> | null;
        readonly best_streak?: number | null;
        readonly created_at?: string | null;
        readonly current_level?: number | null;
        readonly current_streak?: number | null;
        readonly current_xp?: number | null;
        readonly downvote_count?: number | null;
        readonly id: string;
        readonly interaction_stats?: Record<string, any> | null;
        readonly last_vote_date?: string | null;
        readonly multipliers?: Record<string, any> | null;
        readonly points?: number | null;
        readonly points_breakdown?: Record<string, any> | null;
        readonly titles?: Record<string, any> | null;
        readonly today_vote_count?: number | null;
        readonly total_reading_time?: number | null;
        readonly total_votes?: number | null;
        readonly updated_at?: string | null;
        readonly upvote_count?: number | null;
        readonly user_id: string;
        readonly vote_accuracy?: number | null;
        readonly xp_to_next_level?: number | null;
      } | null;
    }>;
  } | null> | null;
};

export type UpdateManyVoteMutationVariables = Exact<{
  _inc?: InputMaybe<VotesIncInput>;
  _set?: InputMaybe<VotesSetInput>;
  where: VotesBoolExp;
}>;

export type UpdateManyVoteMutationQuery = {
  readonly update_votes?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id: string;
      readonly vote_type: any;
    }>;
  } | null;
};

export type UpdateOneVoteMutationVariables = Exact<{
  _inc?: InputMaybe<VotesIncInput>;
  _set?: InputMaybe<VotesSetInput>;
  pk_columns: VotesPkColumnsInput;
}>;

export type UpdateOneVoteMutationQuery = {
  readonly update_votes_by_pk?: {
    readonly content_id: string;
    readonly content_type: string;
    readonly created_at?: string | null;
    readonly id: string;
    readonly user_id: string;
    readonly vote_type: any;
  } | null;
};

export type UpdateManyVotesManyMutationVariables = Exact<{
  updates: ReadonlyArray<VotesUpdates> | VotesUpdates;
}>;

export type UpdateManyVotesManyMutationQuery = {
  readonly update_votes_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly content_id: string;
      readonly content_type: string;
      readonly created_at?: string | null;
      readonly id: string;
      readonly user_id: string;
      readonly vote_type: any;
    }>;
  } | null> | null;
};

export type UpdateManyWorkflowMutationVariables = 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 UpdateManyWorkflowMutationQuery = {
  readonly update_workflows?: {
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly completed_at?: string | null;
      readonly created_at?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly name: string;
      readonly started_at?: string | null;
      readonly status: any;
      readonly updated_at?: string | null;
    }>;
  } | null;
};

export type UpdateOneWorkflowMutationVariables = 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 UpdateOneWorkflowMutationQuery = {
  readonly update_workflows_by_pk?: {
    readonly completed_at?: string | null;
    readonly created_at?: string | null;
    readonly id: string;
    readonly metadata?: Record<string, any> | null;
    readonly name: string;
    readonly started_at?: string | null;
    readonly status: any;
    readonly updated_at?: string | null;
  } | null;
};

export type UpdateManyWorkflowsManyMutationVariables = Exact<{
  updates: ReadonlyArray<WorkflowsUpdates> | WorkflowsUpdates;
}>;

export type UpdateManyWorkflowsManyMutationQuery = {
  readonly update_workflows_many?: ReadonlyArray<{
    readonly affected_rows: number;
    readonly returning: ReadonlyArray<{
      readonly completed_at?: string | null;
      readonly created_at?: string | null;
      readonly id: string;
      readonly metadata?: Record<string, any> | null;
      readonly name: string;
      readonly started_at?: string | null;
      readonly status: any;
      readonly updated_at?: string | null;
    }>;
  } | null> | null;
};