@incubrain/client/dist/generated/sdk.ts

A type-safe GraphQL client for Hasura, optimized for Node.js and Nuxt environments with full TypeScript support.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export type AddressesAggregateBoolExpCount = {
  arguments?: InputMaybe<Array<AddressesSelectColumn>>;
  distinct?: InputMaybe<Scalars["