@incubrain/client/dist/generated/base-types.d.ts

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

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 */
"ac