@incubrain/client/dist/generated/helpers.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 type { FieldSelection, WhereInput, OrderByInput } from "../client/types";
import type * as Types from "./base-types";

export const selectAdDailyMetrics = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdDailyMetricsSelection {
  ad_variant?:
    | boolean
    | {
        select?: AdVariantsSelection;
        include?: AdVariantsSelection;
      };
  clicks?: boolean | boolean;
  created_at?: boolean | boolean;
  date?: boolean | boolean;
  id?: boolean | boolean;
  updated_at?: boolean | boolean;
  variant_id?: boolean | boolean;
  views?: boolean | boolean;
}

export const includeAdDailyMetrics = <T extends AdDailyMetricsSelection>(
  include: T,
) => include;

export const selectAdDailyMetricsAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdDailyMetricsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: AdDailyMetricsAggregateFieldsSelection;
        include?: AdDailyMetricsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeAdDailyMetricsAggregate = <
  T extends AdDailyMetricsAggregateSelection,
>(
  include: T,
) => include;

export const selectAdDailyMetricsAggregateFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface AdDailyMetricsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: AdDailyMetricsAvgFieldsSelection;
        include?: AdDailyMetricsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: AdDailyMetricsMaxFieldsSelection;
        include?: AdDailyMetricsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: AdDailyMetricsMinFieldsSelection;
        include?: AdDailyMetricsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: AdDailyMetricsStddevFieldsSelection;
        include?: AdDailyMetricsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: AdDailyMetricsStddevPopFieldsSelection;
        include?: AdDailyMetricsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: AdDailyMetricsStddevSampFieldsSelection;
        include?: AdDailyMetricsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: AdDailyMetricsSumFieldsSelection;
        include?: AdDailyMetricsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: AdDailyMetricsVarPopFieldsSelection;
        include?: AdDailyMetricsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: AdDailyMetricsVarSampFieldsSelection;
        include?: AdDailyMetricsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: AdDailyMetricsVarianceFieldsSelection;
        include?: AdDailyMetricsVarianceFieldsSelection;
      };
}

export const includeAdDailyMetricsAggregateFields = <
  T extends AdDailyMetricsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectAdDailyMetricsAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdDailyMetricsAvgFieldsSelection {
  clicks?: boolean | boolean;
  views?: boolean | boolean;
}

export const includeAdDailyMetricsAvgFields = <
  T extends AdDailyMetricsAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectAdDailyMetricsMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdDailyMetricsMaxFieldsSelection {
  clicks?: boolean | boolean;
  created_at?: boolean | boolean;
  date?: boolean | boolean;
  id?: boolean | boolean;
  updated_at?: boolean | boolean;
  variant_id?: boolean | boolean;
  views?: boolean | boolean;
}

export const includeAdDailyMetricsMaxFields = <
  T extends AdDailyMetricsMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectAdDailyMetricsMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdDailyMetricsMinFieldsSelection {
  clicks?: boolean | boolean;
  created_at?: boolean | boolean;
  date?: boolean | boolean;
  id?: boolean | boolean;
  updated_at?: boolean | boolean;
  variant_id?: boolean | boolean;
  views?: boolean | boolean;
}

export const includeAdDailyMetricsMinFields = <
  T extends AdDailyMetricsMinFieldsSelection,
>(
  include: T,
) => include;

export const selectAdDailyMetricsMutationResponse = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface AdDailyMetricsMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeAdDailyMetricsMutationResponse = <
  T extends AdDailyMetricsMutationResponseSelection,
>(
  include: T,
) => include;

export const selectAdDailyMetricsStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdDailyMetricsStddevFieldsSelection {
  clicks?: boolean | boolean;
  views?: boolean | boolean;
}

export const includeAdDailyMetricsStddevFields = <
  T extends AdDailyMetricsStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectAdDailyMetricsStddevPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface AdDailyMetricsStddevPopFieldsSelection {
  clicks?: boolean | boolean;
  views?: boolean | boolean;
}

export const includeAdDailyMetricsStddevPopFields = <
  T extends AdDailyMetricsStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectAdDailyMetricsStddevSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface AdDailyMetricsStddevSampFieldsSelection {
  clicks?: boolean | boolean;
  views?: boolean | boolean;
}

export const includeAdDailyMetricsStddevSampFields = <
  T extends AdDailyMetricsStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectAdDailyMetricsSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdDailyMetricsSumFieldsSelection {
  clicks?: boolean | boolean;
  views?: boolean | boolean;
}

export const includeAdDailyMetricsSumFields = <
  T extends AdDailyMetricsSumFieldsSelection,
>(
  include: T,
) => include;

export const selectAdDailyMetricsVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdDailyMetricsVarPopFieldsSelection {
  clicks?: boolean | boolean;
  views?: boolean | boolean;
}

export const includeAdDailyMetricsVarPopFields = <
  T extends AdDailyMetricsVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectAdDailyMetricsVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdDailyMetricsVarSampFieldsSelection {
  clicks?: boolean | boolean;
  views?: boolean | boolean;
}

export const includeAdDailyMetricsVarSampFields = <
  T extends AdDailyMetricsVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectAdDailyMetricsVarianceFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdDailyMetricsVarianceFieldsSelection {
  clicks?: boolean | boolean;
  views?: boolean | boolean;
}

export const includeAdDailyMetricsVarianceFields = <
  T extends AdDailyMetricsVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectAdPackages = <T extends FieldSelection<T>>(selection: T) =>
  selection;

export interface AdPackagesSelection {
  active?: boolean | boolean;
  ads?: boolean | boolean;
  ads_aggregate?: boolean | boolean;
  avg_roi?: boolean | boolean;
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  expected_ctr?: boolean | boolean;
  features?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  position?: boolean | boolean;
  price?: boolean | boolean;
  updated_at?: boolean | boolean;
  view_frequency?: boolean | boolean;
}

export const includeAdPackages = <T extends AdPackagesSelection>(include: T) =>
  include;

export const selectAdPackagesAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdPackagesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: AdPackagesAggregateFieldsSelection;
        include?: AdPackagesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeAdPackagesAggregate = <
  T extends AdPackagesAggregateSelection,
>(
  include: T,
) => include;

export const selectAdPackagesAggregateFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdPackagesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: AdPackagesAvgFieldsSelection;
        include?: AdPackagesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: AdPackagesMaxFieldsSelection;
        include?: AdPackagesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: AdPackagesMinFieldsSelection;
        include?: AdPackagesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: AdPackagesStddevFieldsSelection;
        include?: AdPackagesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: AdPackagesStddevPopFieldsSelection;
        include?: AdPackagesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: AdPackagesStddevSampFieldsSelection;
        include?: AdPackagesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: AdPackagesSumFieldsSelection;
        include?: AdPackagesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: AdPackagesVarPopFieldsSelection;
        include?: AdPackagesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: AdPackagesVarSampFieldsSelection;
        include?: AdPackagesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: AdPackagesVarianceFieldsSelection;
        include?: AdPackagesVarianceFieldsSelection;
      };
}

export const includeAdPackagesAggregateFields = <
  T extends AdPackagesAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectAdPackagesAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdPackagesAvgFieldsSelection {
  avg_roi?: boolean | boolean;
  expected_ctr?: boolean | boolean;
  price?: boolean | boolean;
  view_frequency?: boolean | boolean;
}

export const includeAdPackagesAvgFields = <
  T extends AdPackagesAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectAdPackagesMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdPackagesMaxFieldsSelection {
  avg_roi?: boolean | boolean;
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  expected_ctr?: boolean | boolean;
  features?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  position?: boolean | boolean;
  price?: boolean | boolean;
  updated_at?: boolean | boolean;
  view_frequency?: boolean | boolean;
}

export const includeAdPackagesMaxFields = <
  T extends AdPackagesMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectAdPackagesMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdPackagesMinFieldsSelection {
  avg_roi?: boolean | boolean;
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  expected_ctr?: boolean | boolean;
  features?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  position?: boolean | boolean;
  price?: boolean | boolean;
  updated_at?: boolean | boolean;
  view_frequency?: boolean | boolean;
}

export const includeAdPackagesMinFields = <
  T extends AdPackagesMinFieldsSelection,
>(
  include: T,
) => include;

export const selectAdPackagesMutationResponse = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdPackagesMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeAdPackagesMutationResponse = <
  T extends AdPackagesMutationResponseSelection,
>(
  include: T,
) => include;

export const selectAdPackagesStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdPackagesStddevFieldsSelection {
  avg_roi?: boolean | boolean;
  expected_ctr?: boolean | boolean;
  price?: boolean | boolean;
  view_frequency?: boolean | boolean;
}

export const includeAdPackagesStddevFields = <
  T extends AdPackagesStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectAdPackagesStddevPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdPackagesStddevPopFieldsSelection {
  avg_roi?: boolean | boolean;
  expected_ctr?: boolean | boolean;
  price?: boolean | boolean;
  view_frequency?: boolean | boolean;
}

export const includeAdPackagesStddevPopFields = <
  T extends AdPackagesStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectAdPackagesStddevSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdPackagesStddevSampFieldsSelection {
  avg_roi?: boolean | boolean;
  expected_ctr?: boolean | boolean;
  price?: boolean | boolean;
  view_frequency?: boolean | boolean;
}

export const includeAdPackagesStddevSampFields = <
  T extends AdPackagesStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectAdPackagesSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdPackagesSumFieldsSelection {
  avg_roi?: boolean | boolean;
  expected_ctr?: boolean | boolean;
  price?: boolean | boolean;
  view_frequency?: boolean | boolean;
}

export const includeAdPackagesSumFields = <
  T extends AdPackagesSumFieldsSelection,
>(
  include: T,
) => include;

export const selectAdPackagesVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdPackagesVarPopFieldsSelection {
  avg_roi?: boolean | boolean;
  expected_ctr?: boolean | boolean;
  price?: boolean | boolean;
  view_frequency?: boolean | boolean;
}

export const includeAdPackagesVarPopFields = <
  T extends AdPackagesVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectAdPackagesVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdPackagesVarSampFieldsSelection {
  avg_roi?: boolean | boolean;
  expected_ctr?: boolean | boolean;
  price?: boolean | boolean;
  view_frequency?: boolean | boolean;
}

export const includeAdPackagesVarSampFields = <
  T extends AdPackagesVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectAdPackagesVarianceFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdPackagesVarianceFieldsSelection {
  avg_roi?: boolean | boolean;
  expected_ctr?: boolean | boolean;
  price?: boolean | boolean;
  view_frequency?: boolean | boolean;
}

export const includeAdPackagesVarianceFields = <
  T extends AdPackagesVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectAdVariants = <T extends FieldSelection<T>>(selection: T) =>
  selection;

export interface AdVariantsSelection {
  active?: boolean | boolean;
  ad?: boolean | boolean;
  ad_daily_metrics?: boolean | boolean;
  ad_daily_metrics_aggregate?: boolean | boolean;
  ad_id?: boolean | boolean;
  content?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  is_control?: boolean | boolean;
  performance_metrics?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeAdVariants = <T extends AdVariantsSelection>(include: T) =>
  include;

export const selectAdVariantsAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdVariantsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: AdVariantsAggregateFieldsSelection;
        include?: AdVariantsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeAdVariantsAggregate = <
  T extends AdVariantsAggregateSelection,
>(
  include: T,
) => include;

export const selectAdVariantsAggregateFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdVariantsAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: AdVariantsMaxFieldsSelection;
        include?: AdVariantsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: AdVariantsMinFieldsSelection;
        include?: AdVariantsMinFieldsSelection;
      };
}

export const includeAdVariantsAggregateFields = <
  T extends AdVariantsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectAdVariantsMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdVariantsMaxFieldsSelection {
  ad_id?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeAdVariantsMaxFields = <
  T extends AdVariantsMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectAdVariantsMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdVariantsMinFieldsSelection {
  ad_id?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeAdVariantsMinFields = <
  T extends AdVariantsMinFieldsSelection,
>(
  include: T,
) => include;

export const selectAdVariantsMutationResponse = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdVariantsMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeAdVariantsMutationResponse = <
  T extends AdVariantsMutationResponseSelection,
>(
  include: T,
) => include;

export const selectAddresses = <T extends FieldSelection<T>>(selection: T) =>
  selection;

export interface AddressesSelection {
  address_type?: boolean | boolean;
  city?: boolean | boolean;
  city_id?: boolean | boolean;
  company?:
    | boolean
    | {
        select?: CompaniesSelection;
        include?: CompaniesSelection;
      };
  company_id?: boolean | boolean;
  country?: boolean | boolean;
  country_id?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  is_primary?: boolean | boolean;
  name?: boolean | boolean;
  street1?: boolean | boolean;
  street2?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
  user_profile?:
    | boolean
    | {
        select?: UserProfilesSelection;
        include?: UserProfilesSelection;
      };
}

export const includeAddresses = <T extends AddressesSelection>(include: T) =>
  include;

export const selectAddressesAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AddressesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: AddressesAggregateFieldsSelection;
        include?: AddressesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeAddressesAggregate = <
  T extends AddressesAggregateSelection,
>(
  include: T,
) => include;

export const selectAddressesAggregateFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AddressesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: AddressesAvgFieldsSelection;
        include?: AddressesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: AddressesMaxFieldsSelection;
        include?: AddressesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: AddressesMinFieldsSelection;
        include?: AddressesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: AddressesStddevFieldsSelection;
        include?: AddressesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: AddressesStddevPopFieldsSelection;
        include?: AddressesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: AddressesStddevSampFieldsSelection;
        include?: AddressesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: AddressesSumFieldsSelection;
        include?: AddressesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: AddressesVarPopFieldsSelection;
        include?: AddressesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: AddressesVarSampFieldsSelection;
        include?: AddressesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: AddressesVarianceFieldsSelection;
        include?: AddressesVarianceFieldsSelection;
      };
}

export const includeAddressesAggregateFields = <
  T extends AddressesAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectAddressesAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AddressesAvgFieldsSelection {
  city_id?: boolean | boolean;
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeAddressesAvgFields = <
  T extends AddressesAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectAddressesMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AddressesMaxFieldsSelection {
  address_type?: boolean | boolean;
  city_id?: boolean | boolean;
  company_id?: boolean | boolean;
  country_id?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  street1?: boolean | boolean;
  street2?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeAddressesMaxFields = <
  T extends AddressesMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectAddressesMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AddressesMinFieldsSelection {
  address_type?: boolean | boolean;
  city_id?: boolean | boolean;
  company_id?: boolean | boolean;
  country_id?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  street1?: boolean | boolean;
  street2?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeAddressesMinFields = <
  T extends AddressesMinFieldsSelection,
>(
  include: T,
) => include;

export const selectAddressesMutationResponse = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AddressesMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeAddressesMutationResponse = <
  T extends AddressesMutationResponseSelection,
>(
  include: T,
) => include;

export const selectAddressesStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AddressesStddevFieldsSelection {
  city_id?: boolean | boolean;
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeAddressesStddevFields = <
  T extends AddressesStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectAddressesStddevPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AddressesStddevPopFieldsSelection {
  city_id?: boolean | boolean;
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeAddressesStddevPopFields = <
  T extends AddressesStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectAddressesStddevSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AddressesStddevSampFieldsSelection {
  city_id?: boolean | boolean;
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeAddressesStddevSampFields = <
  T extends AddressesStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectAddressesSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AddressesSumFieldsSelection {
  city_id?: boolean | boolean;
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeAddressesSumFields = <
  T extends AddressesSumFieldsSelection,
>(
  include: T,
) => include;

export const selectAddressesVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AddressesVarPopFieldsSelection {
  city_id?: boolean | boolean;
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeAddressesVarPopFields = <
  T extends AddressesVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectAddressesVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AddressesVarSampFieldsSelection {
  city_id?: boolean | boolean;
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeAddressesVarSampFields = <
  T extends AddressesVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectAddressesVarianceFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AddressesVarianceFieldsSelection {
  city_id?: boolean | boolean;
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeAddressesVarianceFields = <
  T extends AddressesVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectAds = <T extends FieldSelection<T>>(selection: T) =>
  selection;

export interface AdsSelection {
  active?: boolean | boolean;
  ad_package?:
    | boolean
    | {
        select?: AdPackagesSelection;
        include?: AdPackagesSelection;
      };
  ad_variants?: boolean | boolean;
  ad_variants_aggregate?: boolean | boolean;
  company?:
    | boolean
    | {
        select?: CompaniesSelection;
        include?: CompaniesSelection;
      };
  company_id?: boolean | boolean;
  created_at?: boolean | boolean;
  end_date?: boolean | boolean;
  id?: boolean | boolean;
  package_id?: boolean | boolean;
  start_date?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeAds = <T extends AdsSelection>(include: T) => include;

export const selectAdsAggregate = <T extends FieldSelection<T>>(selection: T) =>
  selection;

export interface AdsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: AdsAggregateFieldsSelection;
        include?: AdsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeAdsAggregate = <T extends AdsAggregateSelection>(
  include: T,
) => include;

export const selectAdsAggregateFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdsAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: AdsMaxFieldsSelection;
        include?: AdsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: AdsMinFieldsSelection;
        include?: AdsMinFieldsSelection;
      };
}

export const includeAdsAggregateFields = <
  T extends AdsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectAdsMaxFields = <T extends FieldSelection<T>>(selection: T) =>
  selection;

export interface AdsMaxFieldsSelection {
  company_id?: boolean | boolean;
  created_at?: boolean | boolean;
  end_date?: boolean | boolean;
  id?: boolean | boolean;
  package_id?: boolean | boolean;
  start_date?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeAdsMaxFields = <T extends AdsMaxFieldsSelection>(
  include: T,
) => include;

export const selectAdsMinFields = <T extends FieldSelection<T>>(selection: T) =>
  selection;

export interface AdsMinFieldsSelection {
  company_id?: boolean | boolean;
  created_at?: boolean | boolean;
  end_date?: boolean | boolean;
  id?: boolean | boolean;
  package_id?: boolean | boolean;
  start_date?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeAdsMinFields = <T extends AdsMinFieldsSelection>(
  include: T,
) => include;

export const selectAdsMutationResponse = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface AdsMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeAdsMutationResponse = <
  T extends AdsMutationResponseSelection,
>(
  include: T,
) => include;

export const selectBlacklistedDomains = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlacklistedDomainsSelection {
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  reason?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeBlacklistedDomains = <
  T extends BlacklistedDomainsSelection,
>(
  include: T,
) => include;

export const selectBlacklistedDomainsAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlacklistedDomainsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: BlacklistedDomainsAggregateFieldsSelection;
        include?: BlacklistedDomainsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeBlacklistedDomainsAggregate = <
  T extends BlacklistedDomainsAggregateSelection,
>(
  include: T,
) => include;

export const selectBlacklistedDomainsAggregateFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface BlacklistedDomainsAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: BlacklistedDomainsMaxFieldsSelection;
        include?: BlacklistedDomainsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: BlacklistedDomainsMinFieldsSelection;
        include?: BlacklistedDomainsMinFieldsSelection;
      };
}

export const includeBlacklistedDomainsAggregateFields = <
  T extends BlacklistedDomainsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectBlacklistedDomainsMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlacklistedDomainsMaxFieldsSelection {
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  reason?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeBlacklistedDomainsMaxFields = <
  T extends BlacklistedDomainsMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectBlacklistedDomainsMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlacklistedDomainsMinFieldsSelection {
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  reason?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeBlacklistedDomainsMinFields = <
  T extends BlacklistedDomainsMinFieldsSelection,
>(
  include: T,
) => include;

export const selectBlacklistedDomainsMutationResponse = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface BlacklistedDomainsMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeBlacklistedDomainsMutationResponse = <
  T extends BlacklistedDomainsMutationResponseSelection,
>(
  include: T,
) => include;

export const selectBlacklistedUrls = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlacklistedUrlsSelection {
  company?:
    | boolean
    | {
        select?: CompaniesSelection;
        include?: CompaniesSelection;
      };
  company_id?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  reason?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeBlacklistedUrls = <T extends BlacklistedUrlsSelection>(
  include: T,
) => include;

export const selectBlacklistedUrlsAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlacklistedUrlsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: BlacklistedUrlsAggregateFieldsSelection;
        include?: BlacklistedUrlsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeBlacklistedUrlsAggregate = <
  T extends BlacklistedUrlsAggregateSelection,
>(
  include: T,
) => include;

export const selectBlacklistedUrlsAggregateFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface BlacklistedUrlsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: BlacklistedUrlsAvgFieldsSelection;
        include?: BlacklistedUrlsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: BlacklistedUrlsMaxFieldsSelection;
        include?: BlacklistedUrlsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: BlacklistedUrlsMinFieldsSelection;
        include?: BlacklistedUrlsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: BlacklistedUrlsStddevFieldsSelection;
        include?: BlacklistedUrlsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: BlacklistedUrlsStddevPopFieldsSelection;
        include?: BlacklistedUrlsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: BlacklistedUrlsStddevSampFieldsSelection;
        include?: BlacklistedUrlsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: BlacklistedUrlsSumFieldsSelection;
        include?: BlacklistedUrlsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: BlacklistedUrlsVarPopFieldsSelection;
        include?: BlacklistedUrlsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: BlacklistedUrlsVarSampFieldsSelection;
        include?: BlacklistedUrlsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: BlacklistedUrlsVarianceFieldsSelection;
        include?: BlacklistedUrlsVarianceFieldsSelection;
      };
}

export const includeBlacklistedUrlsAggregateFields = <
  T extends BlacklistedUrlsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectBlacklistedUrlsAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlacklistedUrlsAvgFieldsSelection {
  id?: boolean | boolean;
}

export const includeBlacklistedUrlsAvgFields = <
  T extends BlacklistedUrlsAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectBlacklistedUrlsMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlacklistedUrlsMaxFieldsSelection {
  company_id?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  reason?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeBlacklistedUrlsMaxFields = <
  T extends BlacklistedUrlsMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectBlacklistedUrlsMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlacklistedUrlsMinFieldsSelection {
  company_id?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  reason?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeBlacklistedUrlsMinFields = <
  T extends BlacklistedUrlsMinFieldsSelection,
>(
  include: T,
) => include;

export const selectBlacklistedUrlsMutationResponse = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface BlacklistedUrlsMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeBlacklistedUrlsMutationResponse = <
  T extends BlacklistedUrlsMutationResponseSelection,
>(
  include: T,
) => include;

export const selectBlacklistedUrlsStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlacklistedUrlsStddevFieldsSelection {
  id?: boolean | boolean;
}

export const includeBlacklistedUrlsStddevFields = <
  T extends BlacklistedUrlsStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectBlacklistedUrlsStddevPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface BlacklistedUrlsStddevPopFieldsSelection {
  id?: boolean | boolean;
}

export const includeBlacklistedUrlsStddevPopFields = <
  T extends BlacklistedUrlsStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectBlacklistedUrlsStddevSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface BlacklistedUrlsStddevSampFieldsSelection {
  id?: boolean | boolean;
}

export const includeBlacklistedUrlsStddevSampFields = <
  T extends BlacklistedUrlsStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectBlacklistedUrlsSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlacklistedUrlsSumFieldsSelection {
  id?: boolean | boolean;
}

export const includeBlacklistedUrlsSumFields = <
  T extends BlacklistedUrlsSumFieldsSelection,
>(
  include: T,
) => include;

export const selectBlacklistedUrlsVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlacklistedUrlsVarPopFieldsSelection {
  id?: boolean | boolean;
}

export const includeBlacklistedUrlsVarPopFields = <
  T extends BlacklistedUrlsVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectBlacklistedUrlsVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlacklistedUrlsVarSampFieldsSelection {
  id?: boolean | boolean;
}

export const includeBlacklistedUrlsVarSampFields = <
  T extends BlacklistedUrlsVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectBlacklistedUrlsVarianceFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface BlacklistedUrlsVarianceFieldsSelection {
  id?: boolean | boolean;
}

export const includeBlacklistedUrlsVarianceFields = <
  T extends BlacklistedUrlsVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectBlockedIps = <T extends FieldSelection<T>>(selection: T) =>
  selection;

export interface BlockedIpsSelection {
  blocked_at?: boolean | boolean;
  blocked_until?: boolean | boolean;
  created_at?: boolean | boolean;
  failed_attempts?: boolean | boolean;
  id?: boolean | boolean;
  ip_address?: boolean | boolean;
  reason?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeBlockedIps = <T extends BlockedIpsSelection>(include: T) =>
  include;

export const selectBlockedIpsAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlockedIpsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: BlockedIpsAggregateFieldsSelection;
        include?: BlockedIpsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeBlockedIpsAggregate = <
  T extends BlockedIpsAggregateSelection,
>(
  include: T,
) => include;

export const selectBlockedIpsAggregateFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlockedIpsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: BlockedIpsAvgFieldsSelection;
        include?: BlockedIpsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: BlockedIpsMaxFieldsSelection;
        include?: BlockedIpsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: BlockedIpsMinFieldsSelection;
        include?: BlockedIpsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: BlockedIpsStddevFieldsSelection;
        include?: BlockedIpsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: BlockedIpsStddevPopFieldsSelection;
        include?: BlockedIpsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: BlockedIpsStddevSampFieldsSelection;
        include?: BlockedIpsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: BlockedIpsSumFieldsSelection;
        include?: BlockedIpsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: BlockedIpsVarPopFieldsSelection;
        include?: BlockedIpsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: BlockedIpsVarSampFieldsSelection;
        include?: BlockedIpsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: BlockedIpsVarianceFieldsSelection;
        include?: BlockedIpsVarianceFieldsSelection;
      };
}

export const includeBlockedIpsAggregateFields = <
  T extends BlockedIpsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectBlockedIpsAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlockedIpsAvgFieldsSelection {
  failed_attempts?: boolean | boolean;
}

export const includeBlockedIpsAvgFields = <
  T extends BlockedIpsAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectBlockedIpsMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlockedIpsMaxFieldsSelection {
  blocked_at?: boolean | boolean;
  blocked_until?: boolean | boolean;
  created_at?: boolean | boolean;
  failed_attempts?: boolean | boolean;
  id?: boolean | boolean;
  reason?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeBlockedIpsMaxFields = <
  T extends BlockedIpsMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectBlockedIpsMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlockedIpsMinFieldsSelection {
  blocked_at?: boolean | boolean;
  blocked_until?: boolean | boolean;
  created_at?: boolean | boolean;
  failed_attempts?: boolean | boolean;
  id?: boolean | boolean;
  reason?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeBlockedIpsMinFields = <
  T extends BlockedIpsMinFieldsSelection,
>(
  include: T,
) => include;

export const selectBlockedIpsMutationResponse = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlockedIpsMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeBlockedIpsMutationResponse = <
  T extends BlockedIpsMutationResponseSelection,
>(
  include: T,
) => include;

export const selectBlockedIpsStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlockedIpsStddevFieldsSelection {
  failed_attempts?: boolean | boolean;
}

export const includeBlockedIpsStddevFields = <
  T extends BlockedIpsStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectBlockedIpsStddevPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlockedIpsStddevPopFieldsSelection {
  failed_attempts?: boolean | boolean;
}

export const includeBlockedIpsStddevPopFields = <
  T extends BlockedIpsStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectBlockedIpsStddevSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlockedIpsStddevSampFieldsSelection {
  failed_attempts?: boolean | boolean;
}

export const includeBlockedIpsStddevSampFields = <
  T extends BlockedIpsStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectBlockedIpsSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlockedIpsSumFieldsSelection {
  failed_attempts?: boolean | boolean;
}

export const includeBlockedIpsSumFields = <
  T extends BlockedIpsSumFieldsSelection,
>(
  include: T,
) => include;

export const selectBlockedIpsVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlockedIpsVarPopFieldsSelection {
  failed_attempts?: boolean | boolean;
}

export const includeBlockedIpsVarPopFields = <
  T extends BlockedIpsVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectBlockedIpsVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlockedIpsVarSampFieldsSelection {
  failed_attempts?: boolean | boolean;
}

export const includeBlockedIpsVarSampFields = <
  T extends BlockedIpsVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectBlockedIpsVarianceFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BlockedIpsVarianceFieldsSelection {
  failed_attempts?: boolean | boolean;
}

export const includeBlockedIpsVarianceFields = <
  T extends BlockedIpsVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectBookmarkFolders = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BookmarkFoldersSelection {
  bookmark_folder?:
    | boolean
    | {
        select?: BookmarkFoldersSelection;
        include?: BookmarkFoldersSelection;
      };
  bookmark_folders?: boolean | boolean;
  bookmark_folders_aggregate?: boolean | boolean;
  bookmarks?: boolean | boolean;
  bookmarks_aggregate?: boolean | boolean;
  color?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  is_default?: boolean | boolean;
  is_favorite?: boolean | boolean;
  name?: boolean | boolean;
  parent_id?: boolean | boolean;
  path?: boolean | boolean;
  position?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeBookmarkFolders = <T extends BookmarkFoldersSelection>(
  include: T,
) => include;

export const selectBookmarkFoldersAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BookmarkFoldersAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: BookmarkFoldersAggregateFieldsSelection;
        include?: BookmarkFoldersAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeBookmarkFoldersAggregate = <
  T extends BookmarkFoldersAggregateSelection,
>(
  include: T,
) => include;

export const selectBookmarkFoldersAggregateFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface BookmarkFoldersAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: BookmarkFoldersAvgFieldsSelection;
        include?: BookmarkFoldersAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: BookmarkFoldersMaxFieldsSelection;
        include?: BookmarkFoldersMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: BookmarkFoldersMinFieldsSelection;
        include?: BookmarkFoldersMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: BookmarkFoldersStddevFieldsSelection;
        include?: BookmarkFoldersStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: BookmarkFoldersStddevPopFieldsSelection;
        include?: BookmarkFoldersStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: BookmarkFoldersStddevSampFieldsSelection;
        include?: BookmarkFoldersStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: BookmarkFoldersSumFieldsSelection;
        include?: BookmarkFoldersSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: BookmarkFoldersVarPopFieldsSelection;
        include?: BookmarkFoldersVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: BookmarkFoldersVarSampFieldsSelection;
        include?: BookmarkFoldersVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: BookmarkFoldersVarianceFieldsSelection;
        include?: BookmarkFoldersVarianceFieldsSelection;
      };
}

export const includeBookmarkFoldersAggregateFields = <
  T extends BookmarkFoldersAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectBookmarkFoldersAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BookmarkFoldersAvgFieldsSelection {
  position?: boolean | boolean;
}

export const includeBookmarkFoldersAvgFields = <
  T extends BookmarkFoldersAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectBookmarkFoldersMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BookmarkFoldersMaxFieldsSelection {
  color?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  parent_id?: boolean | boolean;
  path?: boolean | boolean;
  position?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeBookmarkFoldersMaxFields = <
  T extends BookmarkFoldersMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectBookmarkFoldersMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface BookmarkFoldersMinFieldsSelection {
  color?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  parent_id?: boolean | boolean;
  path?: boolean | boolean;
  position?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeBookmarkFoldersMinFields = <
  T extends BookmarkFoldersMinFieldsSelection,
>(
  include: T,
) => include;

export const selectBookmarkFoldersMut