/* 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 selectBookmarkFoldersMutationResponse = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

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

export const includeBookmarkFoldersMutationResponse = <
  T extends BookmarkFoldersMutationResponseSelection,
>(
  include: T,
) => include;

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

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

export const includeBookmarkFoldersStddevFields = <
  T extends BookmarkFoldersStddevFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeBookmarkFoldersStddevPopFields = <
  T extends BookmarkFoldersStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeBookmarkFoldersStddevSampFields = <
  T extends BookmarkFoldersStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeBookmarkFoldersSumFields = <
  T extends BookmarkFoldersSumFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeBookmarkFoldersVarPopFields = <
  T extends BookmarkFoldersVarPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeBookmarkFoldersVarSampFields = <
  T extends BookmarkFoldersVarSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeBookmarkFoldersVarianceFields = <
  T extends BookmarkFoldersVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface BookmarksSelection {
  bookmark_folder?:
    | boolean
    | {
        select?: BookmarkFoldersSelection;
        include?: BookmarkFoldersSelection;
      };
  content?: boolean | boolean;
  content_id?: boolean | boolean;
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  folder_id?: boolean | boolean;
  id?: boolean | boolean;
  metadata?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeBookmarks = <T extends BookmarksSelection>(include: T) =>
  include;

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

export interface BookmarksAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: BookmarksAggregateFieldsSelection;
        include?: BookmarksAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeBookmarksAggregate = <
  T extends BookmarksAggregateSelection,
>(
  include: T,
) => include;

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

export interface BookmarksAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: BookmarksMaxFieldsSelection;
        include?: BookmarksMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: BookmarksMinFieldsSelection;
        include?: BookmarksMinFieldsSelection;
      };
}

export const includeBookmarksAggregateFields = <
  T extends BookmarksAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface BookmarksMaxFieldsSelection {
  content_id?: boolean | boolean;
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  folder_id?: boolean | boolean;
  id?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeBookmarksMaxFields = <
  T extends BookmarksMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface BookmarksMinFieldsSelection {
  content_id?: boolean | boolean;
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  folder_id?: boolean | boolean;
  id?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeBookmarksMinFields = <
  T extends BookmarksMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeBookmarksMutationResponse = <
  T extends BookmarksMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface BusinessDomainsSelection {
  business_domain?:
    | boolean
    | {
        select?: BusinessDomainsSelection;
        include?: BusinessDomainsSelection;
      };
  business_domains?: boolean | boolean;
  business_domains_aggregate?: boolean | boolean;
  categorized_urls?: boolean | boolean;
  categorized_urls_aggregate?: boolean | boolean;
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  parent_id?: boolean | boolean;
  slug?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeBusinessDomains = <T extends BusinessDomainsSelection>(
  include: T,
) => include;

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

export interface BusinessDomainsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: BusinessDomainsAggregateFieldsSelection;
        include?: BusinessDomainsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeBusinessDomainsAggregate = <
  T extends BusinessDomainsAggregateSelection,
>(
  include: T,
) => include;

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

export interface BusinessDomainsAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: BusinessDomainsMaxFieldsSelection;
        include?: BusinessDomainsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: BusinessDomainsMinFieldsSelection;
        include?: BusinessDomainsMinFieldsSelection;
      };
}

export const includeBusinessDomainsAggregateFields = <
  T extends BusinessDomainsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface BusinessDomainsMaxFieldsSelection {
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  parent_id?: boolean | boolean;
  slug?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeBusinessDomainsMaxFields = <
  T extends BusinessDomainsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface BusinessDomainsMinFieldsSelection {
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  parent_id?: boolean | boolean;
  slug?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeBusinessDomainsMinFields = <
  T extends BusinessDomainsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeBusinessDomainsMutationResponse = <
  T extends BusinessDomainsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface CategoriesSelection {
  body?: boolean | boolean;
  companies?: boolean | boolean;
  companies_aggregate?: boolean | boolean;
  content_categories?: boolean | boolean;
  content_categories_aggregate?: boolean | boolean;
  created_at?: boolean | boolean;
  document_id?: boolean | boolean;
  feed_categories?: boolean | boolean;
  feed_categories_aggregate?: boolean | boolean;
  id?: boolean | boolean;
  locale?: boolean | boolean;
  name?: boolean | boolean;
  news?: boolean | boolean;
  news_aggregate?: boolean | boolean;
  published_at?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeCategories = <T extends CategoriesSelection>(include: T) =>
  include;

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

export interface CategoriesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CategoriesAggregateFieldsSelection;
        include?: CategoriesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCategoriesAggregate = <
  T extends CategoriesAggregateSelection,
>(
  include: T,
) => include;

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

export interface CategoriesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: CategoriesAvgFieldsSelection;
        include?: CategoriesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CategoriesMaxFieldsSelection;
        include?: CategoriesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CategoriesMinFieldsSelection;
        include?: CategoriesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: CategoriesStddevFieldsSelection;
        include?: CategoriesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: CategoriesStddevPopFieldsSelection;
        include?: CategoriesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: CategoriesStddevSampFieldsSelection;
        include?: CategoriesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: CategoriesSumFieldsSelection;
        include?: CategoriesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: CategoriesVarPopFieldsSelection;
        include?: CategoriesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: CategoriesVarSampFieldsSelection;
        include?: CategoriesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: CategoriesVarianceFieldsSelection;
        include?: CategoriesVarianceFieldsSelection;
      };
}

export const includeCategoriesAggregateFields = <
  T extends CategoriesAggregateFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCategoriesAvgFields = <
  T extends CategoriesAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface CategoriesMaxFieldsSelection {
  body?: boolean | boolean;
  created_at?: boolean | boolean;
  document_id?: boolean | boolean;
  id?: boolean | boolean;
  locale?: boolean | boolean;
  name?: boolean | boolean;
  published_at?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeCategoriesMaxFields = <
  T extends CategoriesMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface CategoriesMinFieldsSelection {
  body?: boolean | boolean;
  created_at?: boolean | boolean;
  document_id?: boolean | boolean;
  id?: boolean | boolean;
  locale?: boolean | boolean;
  name?: boolean | boolean;
  published_at?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeCategoriesMinFields = <
  T extends CategoriesMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCategoriesMutationResponse = <
  T extends CategoriesMutationResponseSelection,
>(
  include: T,
) => include;

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

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

export const includeCategoriesStddevFields = <
  T extends CategoriesStddevFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCategoriesStddevPopFields = <
  T extends CategoriesStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCategoriesStddevSampFields = <
  T extends CategoriesStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCategoriesSumFields = <
  T extends CategoriesSumFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCategoriesVarPopFields = <
  T extends CategoriesVarPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCategoriesVarSampFields = <
  T extends CategoriesVarSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCategoriesVarianceFields = <
  T extends CategoriesVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface CategorizedUrlsSelection {
  business_domain?: boolean | boolean;
  categorizer_version?: boolean | boolean;
  company?:
    | boolean
    | {
        select?: CompaniesSelection;
        include?: CompaniesSelection;
      };
  company_id?: boolean | boolean;
  confidence?: boolean | boolean;
  content_hash?: boolean | boolean;
  created_at?: boolean | boolean;
  domain_id?: boolean | boolean;
  found_on?: boolean | boolean;
  id?: boolean | boolean;
  priority?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeCategorizedUrls = <T extends CategorizedUrlsSelection>(
  include: T,
) => include;

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

export interface CategorizedUrlsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CategorizedUrlsAggregateFieldsSelection;
        include?: CategorizedUrlsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCategorizedUrlsAggregate = <
  T extends CategorizedUrlsAggregateSelection,
>(
  include: T,
) => include;

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

export interface CategorizedUrlsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: CategorizedUrlsAvgFieldsSelection;
        include?: CategorizedUrlsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CategorizedUrlsMaxFieldsSelection;
        include?: CategorizedUrlsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CategorizedUrlsMinFieldsSelection;
        include?: CategorizedUrlsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: CategorizedUrlsStddevFieldsSelection;
        include?: CategorizedUrlsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: CategorizedUrlsStddevPopFieldsSelection;
        include?: CategorizedUrlsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: CategorizedUrlsStddevSampFieldsSelection;
        include?: CategorizedUrlsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: CategorizedUrlsSumFieldsSelection;
        include?: CategorizedUrlsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: CategorizedUrlsVarPopFieldsSelection;
        include?: CategorizedUrlsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: CategorizedUrlsVarSampFieldsSelection;
        include?: CategorizedUrlsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: CategorizedUrlsVarianceFieldsSelection;
        include?: CategorizedUrlsVarianceFieldsSelection;
      };
}

export const includeCategorizedUrlsAggregateFields = <
  T extends CategorizedUrlsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface CategorizedUrlsAvgFieldsSelection {
  confidence?: boolean | boolean;
  priority?: boolean | boolean;
}

export const includeCategorizedUrlsAvgFields = <
  T extends CategorizedUrlsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface CategorizedUrlsMaxFieldsSelection {
  categorizer_version?: boolean | boolean;
  company_id?: boolean | boolean;
  confidence?: boolean | boolean;
  content_hash?: boolean | boolean;
  created_at?: boolean | boolean;
  domain_id?: boolean | boolean;
  found_on?: boolean | boolean;
  id?: boolean | boolean;
  priority?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeCategorizedUrlsMaxFields = <
  T extends CategorizedUrlsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface CategorizedUrlsMinFieldsSelection {
  categorizer_version?: boolean | boolean;
  company_id?: boolean | boolean;
  confidence?: boolean | boolean;
  content_hash?: boolean | boolean;
  created_at?: boolean | boolean;
  domain_id?: boolean | boolean;
  found_on?: boolean | boolean;
  id?: boolean | boolean;
  priority?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeCategorizedUrlsMinFields = <
  T extends CategorizedUrlsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCategorizedUrlsMutationResponse = <
  T extends CategorizedUrlsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface CategorizedUrlsStddevFieldsSelection {
  confidence?: boolean | boolean;
  priority?: boolean | boolean;
}

export const includeCategorizedUrlsStddevFields = <
  T extends CategorizedUrlsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface CategorizedUrlsStddevPopFieldsSelection {
  confidence?: boolean | boolean;
  priority?: boolean | boolean;
}

export const includeCategorizedUrlsStddevPopFields = <
  T extends CategorizedUrlsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CategorizedUrlsStddevSampFieldsSelection {
  confidence?: boolean | boolean;
  priority?: boolean | boolean;
}

export const includeCategorizedUrlsStddevSampFields = <
  T extends CategorizedUrlsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CategorizedUrlsSumFieldsSelection {
  confidence?: boolean | boolean;
  priority?: boolean | boolean;
}

export const includeCategorizedUrlsSumFields = <
  T extends CategorizedUrlsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface CategorizedUrlsVarPopFieldsSelection {
  confidence?: boolean | boolean;
  priority?: boolean | boolean;
}

export const includeCategorizedUrlsVarPopFields = <
  T extends CategorizedUrlsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CategorizedUrlsVarSampFieldsSelection {
  confidence?: boolean | boolean;
  priority?: boolean | boolean;
}

export const includeCategorizedUrlsVarSampFields = <
  T extends CategorizedUrlsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CategorizedUrlsVarianceFieldsSelection {
  confidence?: boolean | boolean;
  priority?: boolean | boolean;
}

export const includeCategorizedUrlsVarianceFields = <
  T extends CategorizedUrlsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface CircuitBreakerStatesSelection {
  created_at?: boolean | boolean;
  failure_count?: boolean | boolean;
  id?: boolean | boolean;
  job_name?: boolean | boolean;
  last_failure?: boolean | boolean;
  last_success?: boolean | boolean;
  state?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeCircuitBreakerStates = <
  T extends CircuitBreakerStatesSelection,
>(
  include: T,
) => include;

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

export interface CircuitBreakerStatesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CircuitBreakerStatesAggregateFieldsSelection;
        include?: CircuitBreakerStatesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCircuitBreakerStatesAggregate = <
  T extends CircuitBreakerStatesAggregateSelection,
>(
  include: T,
) => include;

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

export interface CircuitBreakerStatesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: CircuitBreakerStatesAvgFieldsSelection;
        include?: CircuitBreakerStatesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CircuitBreakerStatesMaxFieldsSelection;
        include?: CircuitBreakerStatesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CircuitBreakerStatesMinFieldsSelection;
        include?: CircuitBreakerStatesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: CircuitBreakerStatesStddevFieldsSelection;
        include?: CircuitBreakerStatesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: CircuitBreakerStatesStddevPopFieldsSelection;
        include?: CircuitBreakerStatesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: CircuitBreakerStatesStddevSampFieldsSelection;
        include?: CircuitBreakerStatesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: CircuitBreakerStatesSumFieldsSelection;
        include?: CircuitBreakerStatesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: CircuitBreakerStatesVarPopFieldsSelection;
        include?: CircuitBreakerStatesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: CircuitBreakerStatesVarSampFieldsSelection;
        include?: CircuitBreakerStatesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: CircuitBreakerStatesVarianceFieldsSelection;
        include?: CircuitBreakerStatesVarianceFieldsSelection;
      };
}

export const includeCircuitBreakerStatesAggregateFields = <
  T extends CircuitBreakerStatesAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface CircuitBreakerStatesAvgFieldsSelection {
  failure_count?: boolean | boolean;
}

export const includeCircuitBreakerStatesAvgFields = <
  T extends CircuitBreakerStatesAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface CircuitBreakerStatesMaxFieldsSelection {
  created_at?: boolean | boolean;
  failure_count?: boolean | boolean;
  id?: boolean | boolean;
  job_name?: boolean | boolean;
  last_failure?: boolean | boolean;
  last_success?: boolean | boolean;
  state?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeCircuitBreakerStatesMaxFields = <
  T extends CircuitBreakerStatesMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface CircuitBreakerStatesMinFieldsSelection {
  created_at?: boolean | boolean;
  failure_count?: boolean | boolean;
  id?: boolean | boolean;
  job_name?: boolean | boolean;
  last_failure?: boolean | boolean;
  last_success?: boolean | boolean;
  state?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeCircuitBreakerStatesMinFields = <
  T extends CircuitBreakerStatesMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCircuitBreakerStatesMutationResponse = <
  T extends CircuitBreakerStatesMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface CircuitBreakerStatesStddevFieldsSelection {
  failure_count?: boolean | boolean;
}

export const includeCircuitBreakerStatesStddevFields = <
  T extends CircuitBreakerStatesStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface CircuitBreakerStatesStddevPopFieldsSelection {
  failure_count?: boolean | boolean;
}

export const includeCircuitBreakerStatesStddevPopFields = <
  T extends CircuitBreakerStatesStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CircuitBreakerStatesStddevSampFieldsSelection {
  failure_count?: boolean | boolean;
}

export const includeCircuitBreakerStatesStddevSampFields = <
  T extends CircuitBreakerStatesStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CircuitBreakerStatesSumFieldsSelection {
  failure_count?: boolean | boolean;
}

export const includeCircuitBreakerStatesSumFields = <
  T extends CircuitBreakerStatesSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface CircuitBreakerStatesVarPopFieldsSelection {
  failure_count?: boolean | boolean;
}

export const includeCircuitBreakerStatesVarPopFields = <
  T extends CircuitBreakerStatesVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CircuitBreakerStatesVarSampFieldsSelection {
  failure_count?: boolean | boolean;
}

export const includeCircuitBreakerStatesVarSampFields = <
  T extends CircuitBreakerStatesVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CircuitBreakerStatesVarianceFieldsSelection {
  failure_count?: boolean | boolean;
}

export const includeCircuitBreakerStatesVarianceFields = <
  T extends CircuitBreakerStatesVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface CitiesSelection {
  addresses?: boolean | boolean;
  addresses_aggregate?: boolean | boolean;
  country?: boolean | boolean;
  country_id?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  state?: boolean | boolean;
}

export const includeCities = <T extends CitiesSelection>(include: T) => include;

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

export interface CitiesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CitiesAggregateFieldsSelection;
        include?: CitiesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCitiesAggregate = <T extends CitiesAggregateSelection>(
  include: T,
) => include;

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

export interface CitiesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: CitiesAvgFieldsSelection;
        include?: CitiesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CitiesMaxFieldsSelection;
        include?: CitiesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CitiesMinFieldsSelection;
        include?: CitiesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: CitiesStddevFieldsSelection;
        include?: CitiesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: CitiesStddevPopFieldsSelection;
        include?: CitiesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: CitiesStddevSampFieldsSelection;
        include?: CitiesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: CitiesSumFieldsSelection;
        include?: CitiesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: CitiesVarPopFieldsSelection;
        include?: CitiesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: CitiesVarSampFieldsSelection;
        include?: CitiesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: CitiesVarianceFieldsSelection;
        include?: CitiesVarianceFieldsSelection;
      };
}

export const includeCitiesAggregateFields = <
  T extends CitiesAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface CitiesAvgFieldsSelection {
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCitiesAvgFields = <T extends CitiesAvgFieldsSelection>(
  include: T,
) => include;

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

export interface CitiesMaxFieldsSelection {
  country_id?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  state?: boolean | boolean;
}

export const includeCitiesMaxFields = <T extends CitiesMaxFieldsSelection>(
  include: T,
) => include;

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

export interface CitiesMinFieldsSelection {
  country_id?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  state?: boolean | boolean;
}

export const includeCitiesMinFields = <T extends CitiesMinFieldsSelection>(
  include: T,
) => include;

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

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

export const includeCitiesMutationResponse = <
  T extends CitiesMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface CitiesStddevFieldsSelection {
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCitiesStddevFields = <
  T extends CitiesStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface CitiesStddevPopFieldsSelection {
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCitiesStddevPopFields = <
  T extends CitiesStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CitiesStddevSampFieldsSelection {
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCitiesStddevSampFields = <
  T extends CitiesStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CitiesSumFieldsSelection {
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCitiesSumFields = <T extends CitiesSumFieldsSelection>(
  include: T,
) => include;

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

export interface CitiesVarPopFieldsSelection {
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCitiesVarPopFields = <
  T extends CitiesVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CitiesVarSampFieldsSelection {
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCitiesVarSampFields = <
  T extends CitiesVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CitiesVarianceFieldsSelection {
  country_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCitiesVarianceFields = <
  T extends CitiesVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface CommentsSelection {
  comment?:
    | boolean
    | {
        select?: CommentsSelection;
        include?: CommentsSelection;
      };
  comments?: boolean | boolean;
  comments_aggregate?: boolean | boolean;
  content?: boolean | boolean;
  content_id?: boolean | boolean;
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  parent_comment_id?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
  user_profile?: boolean | boolean;
}

export const includeComments = <T extends CommentsSelection>(include: T) =>
  include;

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

export interface CommentsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CommentsAggregateFieldsSelection;
        include?: CommentsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCommentsAggregate = <T extends CommentsAggregateSelection>(
  include: T,
) => include;

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

export interface CommentsAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CommentsMaxFieldsSelection;
        include?: CommentsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CommentsMinFieldsSelection;
        include?: CommentsMinFieldsSelection;
      };
}

export const includeCommentsAggregateFields = <
  T extends CommentsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface CommentsMaxFieldsSelection {
  content?: boolean | boolean;
  content_id?: boolean | boolean;
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  parent_comment_id?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeCommentsMaxFields = <T extends CommentsMaxFieldsSelection>(
  include: T,
) => include;

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

export interface CommentsMinFieldsSelection {
  content?: boolean | boolean;
  content_id?: boolean | boolean;
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  parent_comment_id?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeCommentsMinFields = <T extends CommentsMinFieldsSelection>(
  include: T,
) => include;

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

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

export const includeCommentsMutationResponse = <
  T extends CommentsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface CompaniesSelection {
  addresses?: boolean | boolean;
  addresses_aggregate?: boolean | boolean;
  ads?: boolean | boolean;
  ads_aggregate?: boolean | boolean;
  blacklisted_urls?: boolean | boolean;
  blacklisted_urls_aggregate?: boolean | boolean;
  categorized_urls?: boolean | boolean;
  categorized_urls_aggregate?: boolean | boolean;
  category?: boolean | boolean;
  categoryByCategoryId?:
    | boolean
    | {
        select?: CategoriesSelection;
        include?: CategoriesSelection;
      };
  category_id?: boolean | boolean;
  company_contacts?: boolean | boolean;
  company_contacts_aggregate?: boolean | boolean;
  company_extras?: boolean | boolean;
  company_extras_aggregate?: boolean | boolean;
  contacts?: boolean | boolean;
  contacts_aggregate?: boolean | boolean;
  content_sources?: boolean | boolean;
  content_sources_aggregate?: boolean | boolean;
  content_status?: boolean | boolean;
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  failed_count?: boolean | boolean;
  founding_year?: boolean | boolean;
  id?: boolean | boolean;
  is_english?: boolean | boolean;
  is_government?: boolean | boolean;
  keywords?: boolean | boolean;
  logo_url?: boolean | boolean;
  name?: boolean | boolean;
  news?: boolean | boolean;
  news_aggregate?: boolean | boolean;
  scrape_frequency?: boolean | boolean;
  scrape_rating?: boolean | boolean;
  scraped_at?: boolean | boolean;
  social_media_id?: boolean | boolean;
  social_medium?:
    | boolean
    | {
        select?: SocialMediaSelection;
        include?: SocialMediaSelection;
      };
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeCompanies = <T extends CompaniesSelection>(include: T) =>
  include;

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

export interface CompaniesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CompaniesAggregateFieldsSelection;
        include?: CompaniesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCompaniesAggregate = <
  T extends CompaniesAggregateSelection,
>(
  include: T,
) => include;

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

export interface CompaniesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: CompaniesAvgFieldsSelection;
        include?: CompaniesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CompaniesMaxFieldsSelection;
        include?: CompaniesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CompaniesMinFieldsSelection;
        include?: CompaniesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: CompaniesStddevFieldsSelection;
        include?: CompaniesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: CompaniesStddevPopFieldsSelection;
        include?: CompaniesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: CompaniesStddevSampFieldsSelection;
        include?: CompaniesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: CompaniesSumFieldsSelection;
        include?: CompaniesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: CompaniesVarPopFieldsSelection;
        include?: CompaniesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: CompaniesVarSampFieldsSelection;
        include?: CompaniesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: CompaniesVarianceFieldsSelection;
        include?: CompaniesVarianceFieldsSelection;
      };
}

export const includeCompaniesAggregateFields = <
  T extends CompaniesAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompaniesAvgFieldsSelection {
  category_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  founding_year?: boolean | boolean;
  scrape_rating?: boolean | boolean;
  social_media_id?: boolean | boolean;
}

export const includeCompaniesAvgFields = <
  T extends CompaniesAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompaniesMaxFieldsSelection {
  category?: boolean | boolean;
  category_id?: boolean | boolean;
  content_status?: boolean | boolean;
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  failed_count?: boolean | boolean;
  founding_year?: boolean | boolean;
  id?: boolean | boolean;
  logo_url?: boolean | boolean;
  name?: boolean | boolean;
  scrape_frequency?: boolean | boolean;
  scrape_rating?: boolean | boolean;
  scraped_at?: boolean | boolean;
  social_media_id?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeCompaniesMaxFields = <
  T extends CompaniesMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompaniesMinFieldsSelection {
  category?: boolean | boolean;
  category_id?: boolean | boolean;
  content_status?: boolean | boolean;
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  failed_count?: boolean | boolean;
  founding_year?: boolean | boolean;
  id?: boolean | boolean;
  logo_url?: boolean | boolean;
  name?: boolean | boolean;
  scrape_frequency?: boolean | boolean;
  scrape_rating?: boolean | boolean;
  scraped_at?: boolean | boolean;
  social_media_id?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeCompaniesMinFields = <
  T extends CompaniesMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCompaniesMutationResponse = <
  T extends CompaniesMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface CompaniesStddevFieldsSelection {
  category_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  founding_year?: boolean | boolean;
  scrape_rating?: boolean | boolean;
  social_media_id?: boolean | boolean;
}

export const includeCompaniesStddevFields = <
  T extends CompaniesStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompaniesStddevPopFieldsSelection {
  category_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  founding_year?: boolean | boolean;
  scrape_rating?: boolean | boolean;
  social_media_id?: boolean | boolean;
}

export const includeCompaniesStddevPopFields = <
  T extends CompaniesStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompaniesStddevSampFieldsSelection {
  category_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  founding_year?: boolean | boolean;
  scrape_rating?: boolean | boolean;
  social_media_id?: boolean | boolean;
}

export const includeCompaniesStddevSampFields = <
  T extends CompaniesStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompaniesSumFieldsSelection {
  category_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  founding_year?: boolean | boolean;
  scrape_rating?: boolean | boolean;
  social_media_id?: boolean | boolean;
}

export const includeCompaniesSumFields = <
  T extends CompaniesSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompaniesVarPopFieldsSelection {
  category_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  founding_year?: boolean | boolean;
  scrape_rating?: boolean | boolean;
  social_media_id?: boolean | boolean;
}

export const includeCompaniesVarPopFields = <
  T extends CompaniesVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompaniesVarSampFieldsSelection {
  category_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  founding_year?: boolean | boolean;
  scrape_rating?: boolean | boolean;
  social_media_id?: boolean | boolean;
}

export const includeCompaniesVarSampFields = <
  T extends CompaniesVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompaniesVarianceFieldsSelection {
  category_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  founding_year?: boolean | boolean;
  scrape_rating?: boolean | boolean;
  social_media_id?: boolean | boolean;
}

export const includeCompaniesVarianceFields = <
  T extends CompaniesVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyContactsSelection {
  company?:
    | boolean
    | {
        select?: CompaniesSelection;
        include?: CompaniesSelection;
      };
  company_id?: boolean | boolean;
  contact?: boolean | boolean;
  contact_id?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeCompanyContacts = <T extends CompanyContactsSelection>(
  include: T,
) => include;

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

export interface CompanyContactsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CompanyContactsAggregateFieldsSelection;
        include?: CompanyContactsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCompanyContactsAggregate = <
  T extends CompanyContactsAggregateSelection,
>(
  include: T,
) => include;

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

export interface CompanyContactsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: CompanyContactsAvgFieldsSelection;
        include?: CompanyContactsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CompanyContactsMaxFieldsSelection;
        include?: CompanyContactsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CompanyContactsMinFieldsSelection;
        include?: CompanyContactsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: CompanyContactsStddevFieldsSelection;
        include?: CompanyContactsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: CompanyContactsStddevPopFieldsSelection;
        include?: CompanyContactsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: CompanyContactsStddevSampFieldsSelection;
        include?: CompanyContactsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: CompanyContactsSumFieldsSelection;
        include?: CompanyContactsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: CompanyContactsVarPopFieldsSelection;
        include?: CompanyContactsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: CompanyContactsVarSampFieldsSelection;
        include?: CompanyContactsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: CompanyContactsVarianceFieldsSelection;
        include?: CompanyContactsVarianceFieldsSelection;
      };
}

export const includeCompanyContactsAggregateFields = <
  T extends CompanyContactsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyContactsAvgFieldsSelection {
  contact_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCompanyContactsAvgFields = <
  T extends CompanyContactsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyContactsMaxFieldsSelection {
  company_id?: boolean | boolean;
  contact_id?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeCompanyContactsMaxFields = <
  T extends CompanyContactsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyContactsMinFieldsSelection {
  company_id?: boolean | boolean;
  contact_id?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeCompanyContactsMinFields = <
  T extends CompanyContactsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCompanyContactsMutationResponse = <
  T extends CompanyContactsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface CompanyContactsStddevFieldsSelection {
  contact_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCompanyContactsStddevFields = <
  T extends CompanyContactsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyContactsStddevPopFieldsSelection {
  contact_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCompanyContactsStddevPopFields = <
  T extends CompanyContactsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyContactsStddevSampFieldsSelection {
  contact_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCompanyContactsStddevSampFields = <
  T extends CompanyContactsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyContactsSumFieldsSelection {
  contact_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCompanyContactsSumFields = <
  T extends CompanyContactsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyContactsVarPopFieldsSelection {
  contact_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCompanyContactsVarPopFields = <
  T extends CompanyContactsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyContactsVarSampFieldsSelection {
  contact_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCompanyContactsVarSampFields = <
  T extends CompanyContactsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyContactsVarianceFieldsSelection {
  contact_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeCompanyContactsVarianceFields = <
  T extends CompanyContactsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyEmployeesSelection {
  access_level?: boolean | boolean;
  company_id?: boolean | boolean;
  created_at?: boolean | boolean;
  end_date?: boolean | boolean;
  id?: boolean | boolean;
  job_description?: boolean | boolean;
  role?: boolean | boolean;
  start_date?: boolean | boolean;
  status?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
  user_profile?: boolean | boolean;
}

export const includeCompanyEmployees = <T extends CompanyEmployeesSelection>(
  include: T,
) => include;

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

export interface CompanyEmployeesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CompanyEmployeesAggregateFieldsSelection;
        include?: CompanyEmployeesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCompanyEmployeesAggregate = <
  T extends CompanyEmployeesAggregateSelection,
>(
  include: T,
) => include;

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

export interface CompanyEmployeesAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CompanyEmployeesMaxFieldsSelection;
        include?: CompanyEmployeesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CompanyEmployeesMinFieldsSelection;
        include?: CompanyEmployeesMinFieldsSelection;
      };
}

export const includeCompanyEmployeesAggregateFields = <
  T extends CompanyEmployeesAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyEmployeesMaxFieldsSelection {
  access_level?: boolean | boolean;
  company_id?: boolean | boolean;
  created_at?: boolean | boolean;
  end_date?: boolean | boolean;
  id?: boolean | boolean;
  job_description?: boolean | boolean;
  role?: boolean | boolean;
  start_date?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeCompanyEmployeesMaxFields = <
  T extends CompanyEmployeesMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyEmployeesMinFieldsSelection {
  access_level?: boolean | boolean;
  company_id?: boolean | boolean;
  created_at?: boolean | boolean;
  end_date?: boolean | boolean;
  id?: boolean | boolean;
  job_description?: boolean | boolean;
  role?: boolean | boolean;
  start_date?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeCompanyEmployeesMinFields = <
  T extends CompanyEmployeesMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCompanyEmployeesMutationResponse = <
  T extends CompanyEmployeesMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface CompanyExtrasSelection {
  body?: boolean | boolean;
  category?: boolean | boolean;
  company?:
    | boolean
    | {
        select?: CompaniesSelection;
        include?: CompaniesSelection;
      };
  company_id?: boolean | boolean;
  created_at?: boolean | boolean;
  found_count?: boolean | boolean;
  id?: boolean | boolean;
  level?: boolean | boolean;
  review?: boolean | boolean;
  success?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeCompanyExtras = <T extends CompanyExtrasSelection>(
  include: T,
) => include;

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

export interface CompanyExtrasAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CompanyExtrasAggregateFieldsSelection;
        include?: CompanyExtrasAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCompanyExtrasAggregate = <
  T extends CompanyExtrasAggregateSelection,
>(
  include: T,
) => include;

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

export interface CompanyExtrasAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: CompanyExtrasAvgFieldsSelection;
        include?: CompanyExtrasAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CompanyExtrasMaxFieldsSelection;
        include?: CompanyExtrasMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CompanyExtrasMinFieldsSelection;
        include?: CompanyExtrasMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: CompanyExtrasStddevFieldsSelection;
        include?: CompanyExtrasStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: CompanyExtrasStddevPopFieldsSelection;
        include?: CompanyExtrasStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: CompanyExtrasStddevSampFieldsSelection;
        include?: CompanyExtrasStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: CompanyExtrasSumFieldsSelection;
        include?: CompanyExtrasSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: CompanyExtrasVarPopFieldsSelection;
        include?: CompanyExtrasVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: CompanyExtrasVarSampFieldsSelection;
        include?: CompanyExtrasVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: CompanyExtrasVarianceFieldsSelection;
        include?: CompanyExtrasVarianceFieldsSelection;
      };
}

export const includeCompanyExtrasAggregateFields = <
  T extends CompanyExtrasAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyExtrasAvgFieldsSelection {
  found_count?: boolean | boolean;
  id?: boolean | boolean;
  level?: boolean | boolean;
}

export const includeCompanyExtrasAvgFields = <
  T extends CompanyExtrasAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyExtrasMaxFieldsSelection {
  body?: boolean | boolean;
  category?: boolean | boolean;
  company_id?: boolean | boolean;
  created_at?: boolean | boolean;
  found_count?: boolean | boolean;
  id?: boolean | boolean;
  level?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeCompanyExtrasMaxFields = <
  T extends CompanyExtrasMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyExtrasMinFieldsSelection {
  body?: boolean | boolean;
  category?: boolean | boolean;
  company_id?: boolean | boolean;
  created_at?: boolean | boolean;
  found_count?: boolean | boolean;
  id?: boolean | boolean;
  level?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeCompanyExtrasMinFields = <
  T extends CompanyExtrasMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCompanyExtrasMutationResponse = <
  T extends CompanyExtrasMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface CompanyExtrasStddevFieldsSelection {
  found_count?: boolean | boolean;
  id?: boolean | boolean;
  level?: boolean | boolean;
}

export const includeCompanyExtrasStddevFields = <
  T extends CompanyExtrasStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyExtrasStddevPopFieldsSelection {
  found_count?: boolean | boolean;
  id?: boolean | boolean;
  level?: boolean | boolean;
}

export const includeCompanyExtrasStddevPopFields = <
  T extends CompanyExtrasStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyExtrasStddevSampFieldsSelection {
  found_count?: boolean | boolean;
  id?: boolean | boolean;
  level?: boolean | boolean;
}

export const includeCompanyExtrasStddevSampFields = <
  T extends CompanyExtrasStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyExtrasSumFieldsSelection {
  found_count?: boolean | boolean;
  id?: boolean | boolean;
  level?: boolean | boolean;
}

export const includeCompanyExtrasSumFields = <
  T extends CompanyExtrasSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyExtrasVarPopFieldsSelection {
  found_count?: boolean | boolean;
  id?: boolean | boolean;
  level?: boolean | boolean;
}

export const includeCompanyExtrasVarPopFields = <
  T extends CompanyExtrasVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyExtrasVarSampFieldsSelection {
  found_count?: boolean | boolean;
  id?: boolean | boolean;
  level?: boolean | boolean;
}

export const includeCompanyExtrasVarSampFields = <
  T extends CompanyExtrasVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyExtrasVarianceFieldsSelection {
  found_count?: boolean | boolean;
  id?: boolean | boolean;
  level?: boolean | boolean;
}

export const includeCompanyExtrasVarianceFields = <
  T extends CompanyExtrasVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyMetricsSelection {
  company_id?: boolean | boolean;
  crawl_id?: boolean | boolean;
  id?: boolean | boolean;
  metric_definition?:
    | boolean
    | {
        select?: MetricDefinitionsSelection;
        include?: MetricDefinitionsSelection;
      };
  metric_id?: boolean | boolean;
  timestamp?: boolean | boolean;
  value?: boolean | boolean;
}

export const includeCompanyMetrics = <T extends CompanyMetricsSelection>(
  include: T,
) => include;

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

export interface CompanyMetricsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CompanyMetricsAggregateFieldsSelection;
        include?: CompanyMetricsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCompanyMetricsAggregate = <
  T extends CompanyMetricsAggregateSelection,
>(
  include: T,
) => include;

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

export interface CompanyMetricsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: CompanyMetricsAvgFieldsSelection;
        include?: CompanyMetricsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CompanyMetricsMaxFieldsSelection;
        include?: CompanyMetricsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CompanyMetricsMinFieldsSelection;
        include?: CompanyMetricsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: CompanyMetricsStddevFieldsSelection;
        include?: CompanyMetricsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: CompanyMetricsStddevPopFieldsSelection;
        include?: CompanyMetricsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: CompanyMetricsStddevSampFieldsSelection;
        include?: CompanyMetricsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: CompanyMetricsSumFieldsSelection;
        include?: CompanyMetricsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: CompanyMetricsVarPopFieldsSelection;
        include?: CompanyMetricsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: CompanyMetricsVarSampFieldsSelection;
        include?: CompanyMetricsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: CompanyMetricsVarianceFieldsSelection;
        include?: CompanyMetricsVarianceFieldsSelection;
      };
}

export const includeCompanyMetricsAggregateFields = <
  T extends CompanyMetricsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyMetricsAvgFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeCompanyMetricsAvgFields = <
  T extends CompanyMetricsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyMetricsMaxFieldsSelection {
  company_id?: boolean | boolean;
  crawl_id?: boolean | boolean;
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
  timestamp?: boolean | boolean;
}

export const includeCompanyMetricsMaxFields = <
  T extends CompanyMetricsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyMetricsMinFieldsSelection {
  company_id?: boolean | boolean;
  crawl_id?: boolean | boolean;
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
  timestamp?: boolean | boolean;
}

export const includeCompanyMetricsMinFields = <
  T extends CompanyMetricsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCompanyMetricsMutationResponse = <
  T extends CompanyMetricsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface CompanyMetricsStddevFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeCompanyMetricsStddevFields = <
  T extends CompanyMetricsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyMetricsStddevPopFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeCompanyMetricsStddevPopFields = <
  T extends CompanyMetricsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyMetricsStddevSampFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeCompanyMetricsStddevSampFields = <
  T extends CompanyMetricsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyMetricsSumFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeCompanyMetricsSumFields = <
  T extends CompanyMetricsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyMetricsVarPopFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeCompanyMetricsVarPopFields = <
  T extends CompanyMetricsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyMetricsVarSampFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeCompanyMetricsVarSampFields = <
  T extends CompanyMetricsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CompanyMetricsVarianceFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeCompanyMetricsVarianceFields = <
  T extends CompanyMetricsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContactsSelection {
  company?:
    | boolean
    | {
        select?: CompaniesSelection;
        include?: CompaniesSelection;
      };
  company_contacts?: boolean | boolean;
  company_contacts_aggregate?: boolean | boolean;
  company_id?: boolean | boolean;
  contact_type?: boolean | boolean;
  created_at?: boolean | boolean;
  email?: boolean | boolean;
  id?: boolean | boolean;
  is_primary?: boolean | boolean;
  phone?: boolean | boolean;
  privacy_level?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
  user_profile?:
    | boolean
    | {
        select?: UserProfilesSelection;
        include?: UserProfilesSelection;
      };
}

export const includeContacts = <T extends ContactsSelection>(include: T) =>
  include;

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

export interface ContactsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ContactsAggregateFieldsSelection;
        include?: ContactsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeContactsAggregate = <T extends ContactsAggregateSelection>(
  include: T,
) => include;

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

export interface ContactsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ContactsAvgFieldsSelection;
        include?: ContactsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ContactsMaxFieldsSelection;
        include?: ContactsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ContactsMinFieldsSelection;
        include?: ContactsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ContactsStddevFieldsSelection;
        include?: ContactsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ContactsStddevPopFieldsSelection;
        include?: ContactsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ContactsStddevSampFieldsSelection;
        include?: ContactsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ContactsSumFieldsSelection;
        include?: ContactsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ContactsVarPopFieldsSelection;
        include?: ContactsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ContactsVarSampFieldsSelection;
        include?: ContactsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ContactsVarianceFieldsSelection;
        include?: ContactsVarianceFieldsSelection;
      };
}

export const includeContactsAggregateFields = <
  T extends ContactsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeContactsAvgFields = <T extends ContactsAvgFieldsSelection>(
  include: T,
) => include;

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

export interface ContactsMaxFieldsSelection {
  company_id?: boolean | boolean;
  contact_type?: boolean | boolean;
  created_at?: boolean | boolean;
  email?: boolean | boolean;
  id?: boolean | boolean;
  phone?: boolean | boolean;
  privacy_level?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeContactsMaxFields = <T extends ContactsMaxFieldsSelection>(
  include: T,
) => include;

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

export interface ContactsMinFieldsSelection {
  company_id?: boolean | boolean;
  contact_type?: boolean | boolean;
  created_at?: boolean | boolean;
  email?: boolean | boolean;
  id?: boolean | boolean;
  phone?: boolean | boolean;
  privacy_level?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeContactsMinFields = <T extends ContactsMinFieldsSelection>(
  include: T,
) => include;

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

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

export const includeContactsMutationResponse = <
  T extends ContactsMutationResponseSelection,
>(
  include: T,
) => include;

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

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

export const includeContactsStddevFields = <
  T extends ContactsStddevFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeContactsStddevPopFields = <
  T extends ContactsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeContactsStddevSampFields = <
  T extends ContactsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeContactsSumFields = <T extends ContactsSumFieldsSelection>(
  include: T,
) => include;

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

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

export const includeContactsVarPopFields = <
  T extends ContactsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeContactsVarSampFields = <
  T extends ContactsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeContactsVarianceFields = <
  T extends ContactsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentCategoriesSelection {
  category?: boolean | boolean;
  category_id?: boolean | boolean;
  content?: boolean | boolean;
  content_id?: boolean | boolean;
  is_primary?: boolean | boolean;
}

export const includeContentCategories = <T extends ContentCategoriesSelection>(
  include: T,
) => include;

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

export interface ContentCategoriesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ContentCategoriesAggregateFieldsSelection;
        include?: ContentCategoriesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeContentCategoriesAggregate = <
  T extends ContentCategoriesAggregateSelection,
>(
  include: T,
) => include;

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

export interface ContentCategoriesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ContentCategoriesAvgFieldsSelection;
        include?: ContentCategoriesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ContentCategoriesMaxFieldsSelection;
        include?: ContentCategoriesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ContentCategoriesMinFieldsSelection;
        include?: ContentCategoriesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ContentCategoriesStddevFieldsSelection;
        include?: ContentCategoriesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ContentCategoriesStddevPopFieldsSelection;
        include?: ContentCategoriesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ContentCategoriesStddevSampFieldsSelection;
        include?: ContentCategoriesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ContentCategoriesSumFieldsSelection;
        include?: ContentCategoriesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ContentCategoriesVarPopFieldsSelection;
        include?: ContentCategoriesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ContentCategoriesVarSampFieldsSelection;
        include?: ContentCategoriesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ContentCategoriesVarianceFieldsSelection;
        include?: ContentCategoriesVarianceFieldsSelection;
      };
}

export const includeContentCategoriesAggregateFields = <
  T extends ContentCategoriesAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentCategoriesAvgFieldsSelection {
  category_id?: boolean | boolean;
}

export const includeContentCategoriesAvgFields = <
  T extends ContentCategoriesAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentCategoriesMaxFieldsSelection {
  category_id?: boolean | boolean;
  content_id?: boolean | boolean;
}

export const includeContentCategoriesMaxFields = <
  T extends ContentCategoriesMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentCategoriesMinFieldsSelection {
  category_id?: boolean | boolean;
  content_id?: boolean | boolean;
}

export const includeContentCategoriesMinFields = <
  T extends ContentCategoriesMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeContentCategoriesMutationResponse = <
  T extends ContentCategoriesMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface ContentCategoriesStddevFieldsSelection {
  category_id?: boolean | boolean;
}

export const includeContentCategoriesStddevFields = <
  T extends ContentCategoriesStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentCategoriesStddevPopFieldsSelection {
  category_id?: boolean | boolean;
}

export const includeContentCategoriesStddevPopFields = <
  T extends ContentCategoriesStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentCategoriesStddevSampFieldsSelection {
  category_id?: boolean | boolean;
}

export const includeContentCategoriesStddevSampFields = <
  T extends ContentCategoriesStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentCategoriesSumFieldsSelection {
  category_id?: boolean | boolean;
}

export const includeContentCategoriesSumFields = <
  T extends ContentCategoriesSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentCategoriesVarPopFieldsSelection {
  category_id?: boolean | boolean;
}

export const includeContentCategoriesVarPopFields = <
  T extends ContentCategoriesVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentCategoriesVarSampFieldsSelection {
  category_id?: boolean | boolean;
}

export const includeContentCategoriesVarSampFields = <
  T extends ContentCategoriesVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentCategoriesVarianceFieldsSelection {
  category_id?: boolean | boolean;
}

export const includeContentCategoriesVarianceFields = <
  T extends ContentCategoriesVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentScoresSelection {
  categories?: boolean | boolean;
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  hot_score?: boolean | boolean;
  id?: boolean | boolean;
  status?: boolean | boolean;
  tags?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeContentScores = <T extends ContentScoresSelection>(
  include: T,
) => include;

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

export interface ContentScoresAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ContentScoresAggregateFieldsSelection;
        include?: ContentScoresAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeContentScoresAggregate = <
  T extends ContentScoresAggregateSelection,
>(
  include: T,
) => include;

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

export interface ContentScoresAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ContentScoresAvgFieldsSelection;
        include?: ContentScoresAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ContentScoresMaxFieldsSelection;
        include?: ContentScoresMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ContentScoresMinFieldsSelection;
        include?: ContentScoresMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ContentScoresStddevFieldsSelection;
        include?: ContentScoresStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ContentScoresStddevPopFieldsSelection;
        include?: ContentScoresStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ContentScoresStddevSampFieldsSelection;
        include?: ContentScoresStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ContentScoresSumFieldsSelection;
        include?: ContentScoresSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ContentScoresVarPopFieldsSelection;
        include?: ContentScoresVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ContentScoresVarSampFieldsSelection;
        include?: ContentScoresVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ContentScoresVarianceFieldsSelection;
        include?: ContentScoresVarianceFieldsSelection;
      };
}

export const includeContentScoresAggregateFields = <
  T extends ContentScoresAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentScoresAvgFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentScoresAvgFields = <
  T extends ContentScoresAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentScoresMaxFieldsSelection {
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  hot_score?: boolean | boolean;
  id?: boolean | boolean;
  status?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeContentScoresMaxFields = <
  T extends ContentScoresMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentScoresMinFieldsSelection {
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  hot_score?: boolean | boolean;
  id?: boolean | boolean;
  status?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeContentScoresMinFields = <
  T extends ContentScoresMinFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentScoresStddevFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentScoresStddevFields = <
  T extends ContentScoresStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentScoresStddevPopFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentScoresStddevPopFields = <
  T extends ContentScoresStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentScoresStddevSampFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentScoresStddevSampFields = <
  T extends ContentScoresStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentScoresSumFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentScoresSumFields = <
  T extends ContentScoresSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentScoresVarPopFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentScoresVarPopFields = <
  T extends ContentScoresVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentScoresVarSampFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentScoresVarSampFields = <
  T extends ContentScoresVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentScoresVarianceFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentScoresVarianceFields = <
  T extends ContentScoresVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentSourceVisitsSelection {
  content?: boolean | boolean;
  content_id?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  user_id?: boolean | boolean;
  user_profile?:
    | boolean
    | {
        select?: UserProfilesSelection;
        include?: UserProfilesSelection;
      };
}

export const includeContentSourceVisits = <
  T extends ContentSourceVisitsSelection,
>(
  include: T,
) => include;

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

export interface ContentSourceVisitsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ContentSourceVisitsAggregateFieldsSelection;
        include?: ContentSourceVisitsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeContentSourceVisitsAggregate = <
  T extends ContentSourceVisitsAggregateSelection,
>(
  include: T,
) => include;

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

export interface ContentSourceVisitsAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ContentSourceVisitsMaxFieldsSelection;
        include?: ContentSourceVisitsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ContentSourceVisitsMinFieldsSelection;
        include?: ContentSourceVisitsMinFieldsSelection;
      };
}

export const includeContentSourceVisitsAggregateFields = <
  T extends ContentSourceVisitsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentSourceVisitsMaxFieldsSelection {
  content_id?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeContentSourceVisitsMaxFields = <
  T extends ContentSourceVisitsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentSourceVisitsMinFieldsSelection {
  content_id?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeContentSourceVisitsMinFields = <
  T extends ContentSourceVisitsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeContentSourceVisitsMutationResponse = <
  T extends ContentSourceVisitsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface ContentSourcesSelection {
  company?:
    | boolean
    | {
        select?: CompaniesSelection;
        include?: CompaniesSelection;
      };
  company_id?: boolean | boolean;
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  expected_count?: boolean | boolean;
  failed_count?: boolean | boolean;
  feed_sources?: boolean | boolean;
  feed_sources_aggregate?: boolean | boolean;
  has_failed?: boolean | boolean;
  hash?: boolean | boolean;
  id?: boolean | boolean;
  news?: boolean | boolean;
  news_aggregate?: boolean | boolean;
  priority?: boolean | boolean;
  refreshed_at?: boolean | boolean;
  rss_urls?: boolean | boolean;
  scrape_frequency?: boolean | boolean;
  scraped_at?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeContentSources = <T extends ContentSourcesSelection>(
  include: T,
) => include;

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

export interface ContentSourcesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ContentSourcesAggregateFieldsSelection;
        include?: ContentSourcesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeContentSourcesAggregate = <
  T extends ContentSourcesAggregateSelection,
>(
  include: T,
) => include;

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

export interface ContentSourcesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ContentSourcesAvgFieldsSelection;
        include?: ContentSourcesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ContentSourcesMaxFieldsSelection;
        include?: ContentSourcesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ContentSourcesMinFieldsSelection;
        include?: ContentSourcesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ContentSourcesStddevFieldsSelection;
        include?: ContentSourcesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ContentSourcesStddevPopFieldsSelection;
        include?: ContentSourcesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ContentSourcesStddevSampFieldsSelection;
        include?: ContentSourcesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ContentSourcesSumFieldsSelection;
        include?: ContentSourcesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ContentSourcesVarPopFieldsSelection;
        include?: ContentSourcesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ContentSourcesVarSampFieldsSelection;
        include?: ContentSourcesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ContentSourcesVarianceFieldsSelection;
        include?: ContentSourcesVarianceFieldsSelection;
      };
}

export const includeContentSourcesAggregateFields = <
  T extends ContentSourcesAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentSourcesAvgFieldsSelection {
  expected_count?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeContentSourcesAvgFields = <
  T extends ContentSourcesAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentSourcesMaxFieldsSelection {
  company_id?: boolean | boolean;
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  expected_count?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
  id?: boolean | boolean;
  priority?: boolean | boolean;
  refreshed_at?: boolean | boolean;
  rss_urls?: boolean | boolean;
  scrape_frequency?: boolean | boolean;
  scraped_at?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeContentSourcesMaxFields = <
  T extends ContentSourcesMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentSourcesMinFieldsSelection {
  company_id?: boolean | boolean;
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  expected_count?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
  id?: boolean | boolean;
  priority?: boolean | boolean;
  refreshed_at?: boolean | boolean;
  rss_urls?: boolean | boolean;
  scrape_frequency?: boolean | boolean;
  scraped_at?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeContentSourcesMinFields = <
  T extends ContentSourcesMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeContentSourcesMutationResponse = <
  T extends ContentSourcesMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface ContentSourcesStddevFieldsSelection {
  expected_count?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeContentSourcesStddevFields = <
  T extends ContentSourcesStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentSourcesStddevPopFieldsSelection {
  expected_count?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeContentSourcesStddevPopFields = <
  T extends ContentSourcesStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentSourcesStddevSampFieldsSelection {
  expected_count?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeContentSourcesStddevSampFields = <
  T extends ContentSourcesStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentSourcesSumFieldsSelection {
  expected_count?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeContentSourcesSumFields = <
  T extends ContentSourcesSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentSourcesVarPopFieldsSelection {
  expected_count?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeContentSourcesVarPopFields = <
  T extends ContentSourcesVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentSourcesVarSampFieldsSelection {
  expected_count?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeContentSourcesVarSampFields = <
  T extends ContentSourcesVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentSourcesVarianceFieldsSelection {
  expected_count?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeContentSourcesVarianceFields = <
  T extends ContentSourcesVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentStatusesSelection {
  content?: boolean | boolean;
  content_id?: boolean | boolean;
  content_status?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  notes?: boolean | boolean;
}

export const includeContentStatuses = <T extends ContentStatusesSelection>(
  include: T,
) => include;

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

export interface ContentStatusesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ContentStatusesAggregateFieldsSelection;
        include?: ContentStatusesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeContentStatusesAggregate = <
  T extends ContentStatusesAggregateSelection,
>(
  include: T,
) => include;

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

export interface ContentStatusesAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ContentStatusesMaxFieldsSelection;
        include?: ContentStatusesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ContentStatusesMinFieldsSelection;
        include?: ContentStatusesMinFieldsSelection;
      };
}

export const includeContentStatusesAggregateFields = <
  T extends ContentStatusesAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentStatusesMaxFieldsSelection {
  content_id?: boolean | boolean;
  content_status?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  notes?: boolean | boolean;
}

export const includeContentStatusesMaxFields = <
  T extends ContentStatusesMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentStatusesMinFieldsSelection {
  content_id?: boolean | boolean;
  content_status?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  notes?: boolean | boolean;
}

export const includeContentStatusesMinFields = <
  T extends ContentStatusesMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeContentStatusesMutationResponse = <
  T extends ContentStatusesMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface ContentTagsSelection {
  content?: boolean | boolean;
  content_id?: boolean | boolean;
  tag?: boolean | boolean;
  tag_id?: boolean | boolean;
}

export const includeContentTags = <T extends ContentTagsSelection>(
  include: T,
) => include;

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

export interface ContentTagsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ContentTagsAggregateFieldsSelection;
        include?: ContentTagsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeContentTagsAggregate = <
  T extends ContentTagsAggregateSelection,
>(
  include: T,
) => include;

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

export interface ContentTagsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ContentTagsAvgFieldsSelection;
        include?: ContentTagsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ContentTagsMaxFieldsSelection;
        include?: ContentTagsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ContentTagsMinFieldsSelection;
        include?: ContentTagsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ContentTagsStddevFieldsSelection;
        include?: ContentTagsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ContentTagsStddevPopFieldsSelection;
        include?: ContentTagsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ContentTagsStddevSampFieldsSelection;
        include?: ContentTagsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ContentTagsSumFieldsSelection;
        include?: ContentTagsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ContentTagsVarPopFieldsSelection;
        include?: ContentTagsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ContentTagsVarSampFieldsSelection;
        include?: ContentTagsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ContentTagsVarianceFieldsSelection;
        include?: ContentTagsVarianceFieldsSelection;
      };
}

export const includeContentTagsAggregateFields = <
  T extends ContentTagsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentTagsAvgFieldsSelection {
  tag_id?: boolean | boolean;
}

export const includeContentTagsAvgFields = <
  T extends ContentTagsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentTagsMaxFieldsSelection {
  content_id?: boolean | boolean;
  tag_id?: boolean | boolean;
}

export const includeContentTagsMaxFields = <
  T extends ContentTagsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentTagsMinFieldsSelection {
  content_id?: boolean | boolean;
  tag_id?: boolean | boolean;
}

export const includeContentTagsMinFields = <
  T extends ContentTagsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeContentTagsMutationResponse = <
  T extends ContentTagsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface ContentTagsStddevFieldsSelection {
  tag_id?: boolean | boolean;
}

export const includeContentTagsStddevFields = <
  T extends ContentTagsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentTagsStddevPopFieldsSelection {
  tag_id?: boolean | boolean;
}

export const includeContentTagsStddevPopFields = <
  T extends ContentTagsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentTagsStddevSampFieldsSelection {
  tag_id?: boolean | boolean;
}

export const includeContentTagsStddevSampFields = <
  T extends ContentTagsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentTagsSumFieldsSelection {
  tag_id?: boolean | boolean;
}

export const includeContentTagsSumFields = <
  T extends ContentTagsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentTagsVarPopFieldsSelection {
  tag_id?: boolean | boolean;
}

export const includeContentTagsVarPopFields = <
  T extends ContentTagsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentTagsVarSampFieldsSelection {
  tag_id?: boolean | boolean;
}

export const includeContentTagsVarSampFields = <
  T extends ContentTagsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentTagsVarianceFieldsSelection {
  tag_id?: boolean | boolean;
}

export const includeContentTagsVarianceFields = <
  T extends ContentTagsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentsSelection {
  bookmarks?: boolean | boolean;
  bookmarks_aggregate?: boolean | boolean;
  content_categories?: boolean | boolean;
  content_categories_aggregate?: boolean | boolean;
  content_source_visits?: boolean | boolean;
  content_source_visits_aggregate?: boolean | boolean;
  content_statuses?: boolean | boolean;
  content_statuses_aggregate?: boolean | boolean;
  content_tags?: boolean | boolean;
  content_tags_aggregate?: boolean | boolean;
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  hot_score?: boolean | boolean;
  id?: boolean | boolean;
  news?:
    | boolean
    | {
        select?: NewsSelection;
        include?: NewsSelection;
      };
  newsletter?:
    | boolean
    | {
        select?: NewslettersSelection;
        include?: NewslettersSelection;
      };
  research?:
    | boolean
    | {
        select?: ResearchSelection;
        include?: ResearchSelection;
      };
  rss_url?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeContents = <T extends ContentsSelection>(include: T) =>
  include;

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

export interface ContentsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ContentsAggregateFieldsSelection;
        include?: ContentsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeContentsAggregate = <T extends ContentsAggregateSelection>(
  include: T,
) => include;

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

export interface ContentsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ContentsAvgFieldsSelection;
        include?: ContentsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ContentsMaxFieldsSelection;
        include?: ContentsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ContentsMinFieldsSelection;
        include?: ContentsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ContentsStddevFieldsSelection;
        include?: ContentsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ContentsStddevPopFieldsSelection;
        include?: ContentsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ContentsStddevSampFieldsSelection;
        include?: ContentsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ContentsSumFieldsSelection;
        include?: ContentsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ContentsVarPopFieldsSelection;
        include?: ContentsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ContentsVarSampFieldsSelection;
        include?: ContentsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ContentsVarianceFieldsSelection;
        include?: ContentsVarianceFieldsSelection;
      };
}

export const includeContentsAggregateFields = <
  T extends ContentsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentsAvgFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentsAvgFields = <T extends ContentsAvgFieldsSelection>(
  include: T,
) => include;

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

export interface ContentsMaxFieldsSelection {
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  hot_score?: boolean | boolean;
  id?: boolean | boolean;
  rss_url?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeContentsMaxFields = <T extends ContentsMaxFieldsSelection>(
  include: T,
) => include;

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

export interface ContentsMinFieldsSelection {
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  hot_score?: boolean | boolean;
  id?: boolean | boolean;
  rss_url?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeContentsMinFields = <T extends ContentsMinFieldsSelection>(
  include: T,
) => include;

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

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

export const includeContentsMutationResponse = <
  T extends ContentsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface ContentsStddevFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentsStddevFields = <
  T extends ContentsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentsStddevPopFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentsStddevPopFields = <
  T extends ContentsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentsStddevSampFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentsStddevSampFields = <
  T extends ContentsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentsSumFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentsSumFields = <T extends ContentsSumFieldsSelection>(
  include: T,
) => include;

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

export interface ContentsVarPopFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentsVarPopFields = <
  T extends ContentsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentsVarSampFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentsVarSampFields = <
  T extends ContentsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ContentsVarianceFieldsSelection {
  hot_score?: boolean | boolean;
}

export const includeContentsVarianceFields = <
  T extends ContentsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface CountriesSelection {
  addresses?: boolean | boolean;
  addresses_aggregate?: boolean | boolean;
  cities?: boolean | boolean;
  cities_aggregate?: boolean | boolean;
  code?: boolean | boolean;
  code_3?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
}

export const includeCountries = <T extends CountriesSelection>(include: T) =>
  include;

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

export interface CountriesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CountriesAggregateFieldsSelection;
        include?: CountriesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCountriesAggregate = <
  T extends CountriesAggregateSelection,
>(
  include: T,
) => include;

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

export interface CountriesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: CountriesAvgFieldsSelection;
        include?: CountriesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CountriesMaxFieldsSelection;
        include?: CountriesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CountriesMinFieldsSelection;
        include?: CountriesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: CountriesStddevFieldsSelection;
        include?: CountriesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: CountriesStddevPopFieldsSelection;
        include?: CountriesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: CountriesStddevSampFieldsSelection;
        include?: CountriesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: CountriesSumFieldsSelection;
        include?: CountriesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: CountriesVarPopFieldsSelection;
        include?: CountriesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: CountriesVarSampFieldsSelection;
        include?: CountriesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: CountriesVarianceFieldsSelection;
        include?: CountriesVarianceFieldsSelection;
      };
}

export const includeCountriesAggregateFields = <
  T extends CountriesAggregateFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCountriesAvgFields = <
  T extends CountriesAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface CountriesMaxFieldsSelection {
  code?: boolean | boolean;
  code_3?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
}

export const includeCountriesMaxFields = <
  T extends CountriesMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface CountriesMinFieldsSelection {
  code?: boolean | boolean;
  code_3?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
}

export const includeCountriesMinFields = <
  T extends CountriesMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCountriesMutationResponse = <
  T extends CountriesMutationResponseSelection,
>(
  include: T,
) => include;

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

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

export const includeCountriesStddevFields = <
  T extends CountriesStddevFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCountriesStddevPopFields = <
  T extends CountriesStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCountriesStddevSampFields = <
  T extends CountriesStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCountriesSumFields = <
  T extends CountriesSumFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCountriesVarPopFields = <
  T extends CountriesVarPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCountriesVarSampFields = <
  T extends CountriesVarSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCountriesVarianceFields = <
  T extends CountriesVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerPaymentsSelection {
  acquirer_data?: boolean | boolean;
  amount?: boolean | boolean;
  amount_refunded?: boolean | boolean;
  amount_transferred?: boolean | boolean;
  bank?: boolean | boolean;
  captured?: boolean | boolean;
  created_at?: boolean | boolean;
  currency?: boolean | boolean;
  customer_refunds?: boolean | boolean;
  customer_refunds_aggregate?: boolean | boolean;
  customer_subscription?:
    | boolean
    | {
        select?: CustomerSubscriptionsSelection;
        include?: CustomerSubscriptionsSelection;
      };
  description?: boolean | boolean;
  error_code?: boolean | boolean;
  error_description?: boolean | boolean;
  error_reason?: boolean | boolean;
  error_source?: boolean | boolean;
  error_step?: boolean | boolean;
  external_order_id?: boolean | boolean;
  external_payment_id?: boolean | boolean;
  fee?: boolean | boolean;
  id?: boolean | boolean;
  international?: boolean | boolean;
  invoice_id?: boolean | boolean;
  method?: boolean | boolean;
  notes?: boolean | boolean;
  order_id?: boolean | boolean;
  payment_provider?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  refund_status?: boolean | boolean;
  status?: boolean | boolean;
  subscription_id?: boolean | boolean;
  tax?: boolean | boolean;
  user_id?: boolean | boolean;
  user_profile?: boolean | boolean;
  vpa?: boolean | boolean;
  wallet?: boolean | boolean;
}

export const includeCustomerPayments = <T extends CustomerPaymentsSelection>(
  include: T,
) => include;

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

export interface CustomerPaymentsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CustomerPaymentsAggregateFieldsSelection;
        include?: CustomerPaymentsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCustomerPaymentsAggregate = <
  T extends CustomerPaymentsAggregateSelection,
>(
  include: T,
) => include;

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

export interface CustomerPaymentsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: CustomerPaymentsAvgFieldsSelection;
        include?: CustomerPaymentsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CustomerPaymentsMaxFieldsSelection;
        include?: CustomerPaymentsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CustomerPaymentsMinFieldsSelection;
        include?: CustomerPaymentsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: CustomerPaymentsStddevFieldsSelection;
        include?: CustomerPaymentsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: CustomerPaymentsStddevPopFieldsSelection;
        include?: CustomerPaymentsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: CustomerPaymentsStddevSampFieldsSelection;
        include?: CustomerPaymentsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: CustomerPaymentsSumFieldsSelection;
        include?: CustomerPaymentsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: CustomerPaymentsVarPopFieldsSelection;
        include?: CustomerPaymentsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: CustomerPaymentsVarSampFieldsSelection;
        include?: CustomerPaymentsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: CustomerPaymentsVarianceFieldsSelection;
        include?: CustomerPaymentsVarianceFieldsSelection;
      };
}

export const includeCustomerPaymentsAggregateFields = <
  T extends CustomerPaymentsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerPaymentsAvgFieldsSelection {
  amount?: boolean | boolean;
  amount_refunded?: boolean | boolean;
  amount_transferred?: boolean | boolean;
  fee?: boolean | boolean;
  id?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  subscription_id?: boolean | boolean;
  tax?: boolean | boolean;
}

export const includeCustomerPaymentsAvgFields = <
  T extends CustomerPaymentsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerPaymentsMaxFieldsSelection {
  amount?: boolean | boolean;
  amount_refunded?: boolean | boolean;
  amount_transferred?: boolean | boolean;
  bank?: boolean | boolean;
  created_at?: boolean | boolean;
  currency?: boolean | boolean;
  description?: boolean | boolean;
  error_code?: boolean | boolean;
  error_description?: boolean | boolean;
  error_reason?: boolean | boolean;
  error_source?: boolean | boolean;
  error_step?: boolean | boolean;
  external_order_id?: boolean | boolean;
  external_payment_id?: boolean | boolean;
  fee?: boolean | boolean;
  id?: boolean | boolean;
  invoice_id?: boolean | boolean;
  method?: boolean | boolean;
  order_id?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  refund_status?: boolean | boolean;
  status?: boolean | boolean;
  subscription_id?: boolean | boolean;
  tax?: boolean | boolean;
  user_id?: boolean | boolean;
  vpa?: boolean | boolean;
  wallet?: boolean | boolean;
}

export const includeCustomerPaymentsMaxFields = <
  T extends CustomerPaymentsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerPaymentsMinFieldsSelection {
  amount?: boolean | boolean;
  amount_refunded?: boolean | boolean;
  amount_transferred?: boolean | boolean;
  bank?: boolean | boolean;
  created_at?: boolean | boolean;
  currency?: boolean | boolean;
  description?: boolean | boolean;
  error_code?: boolean | boolean;
  error_description?: boolean | boolean;
  error_reason?: boolean | boolean;
  error_source?: boolean | boolean;
  error_step?: boolean | boolean;
  external_order_id?: boolean | boolean;
  external_payment_id?: boolean | boolean;
  fee?: boolean | boolean;
  id?: boolean | boolean;
  invoice_id?: boolean | boolean;
  method?: boolean | boolean;
  order_id?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  refund_status?: boolean | boolean;
  status?: boolean | boolean;
  subscription_id?: boolean | boolean;
  tax?: boolean | boolean;
  user_id?: boolean | boolean;
  vpa?: boolean | boolean;
  wallet?: boolean | boolean;
}

export const includeCustomerPaymentsMinFields = <
  T extends CustomerPaymentsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCustomerPaymentsMutationResponse = <
  T extends CustomerPaymentsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface CustomerPaymentsStddevFieldsSelection {
  amount?: boolean | boolean;
  amount_refunded?: boolean | boolean;
  amount_transferred?: boolean | boolean;
  fee?: boolean | boolean;
  id?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  subscription_id?: boolean | boolean;
  tax?: boolean | boolean;
}

export const includeCustomerPaymentsStddevFields = <
  T extends CustomerPaymentsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerPaymentsStddevPopFieldsSelection {
  amount?: boolean | boolean;
  amount_refunded?: boolean | boolean;
  amount_transferred?: boolean | boolean;
  fee?: boolean | boolean;
  id?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  subscription_id?: boolean | boolean;
  tax?: boolean | boolean;
}

export const includeCustomerPaymentsStddevPopFields = <
  T extends CustomerPaymentsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerPaymentsStddevSampFieldsSelection {
  amount?: boolean | boolean;
  amount_refunded?: boolean | boolean;
  amount_transferred?: boolean | boolean;
  fee?: boolean | boolean;
  id?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  subscription_id?: boolean | boolean;
  tax?: boolean | boolean;
}

export const includeCustomerPaymentsStddevSampFields = <
  T extends CustomerPaymentsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerPaymentsSumFieldsSelection {
  amount?: boolean | boolean;
  amount_refunded?: boolean | boolean;
  amount_transferred?: boolean | boolean;
  fee?: boolean | boolean;
  id?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  subscription_id?: boolean | boolean;
  tax?: boolean | boolean;
}

export const includeCustomerPaymentsSumFields = <
  T extends CustomerPaymentsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerPaymentsVarPopFieldsSelection {
  amount?: boolean | boolean;
  amount_refunded?: boolean | boolean;
  amount_transferred?: boolean | boolean;
  fee?: boolean | boolean;
  id?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  subscription_id?: boolean | boolean;
  tax?: boolean | boolean;
}

export const includeCustomerPaymentsVarPopFields = <
  T extends CustomerPaymentsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerPaymentsVarSampFieldsSelection {
  amount?: boolean | boolean;
  amount_refunded?: boolean | boolean;
  amount_transferred?: boolean | boolean;
  fee?: boolean | boolean;
  id?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  subscription_id?: boolean | boolean;
  tax?: boolean | boolean;
}

export const includeCustomerPaymentsVarSampFields = <
  T extends CustomerPaymentsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerPaymentsVarianceFieldsSelection {
  amount?: boolean | boolean;
  amount_refunded?: boolean | boolean;
  amount_transferred?: boolean | boolean;
  fee?: boolean | boolean;
  id?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  subscription_id?: boolean | boolean;
  tax?: boolean | boolean;
}

export const includeCustomerPaymentsVarianceFields = <
  T extends CustomerPaymentsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerProcessedWebhooksSelection {
  event_id?: boolean | boolean;
  event_type?: boolean | boolean;
  id?: boolean | boolean;
  processed_at?: boolean | boolean;
}

export const includeCustomerProcessedWebhooks = <
  T extends CustomerProcessedWebhooksSelection,
>(
  include: T,
) => include;

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

export interface CustomerProcessedWebhooksAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksAggregateFieldsSelection;
        include?: CustomerProcessedWebhooksAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCustomerProcessedWebhooksAggregate = <
  T extends CustomerProcessedWebhooksAggregateSelection,
>(
  include: T,
) => include;

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

export interface CustomerProcessedWebhooksAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksAvgFieldsSelection;
        include?: CustomerProcessedWebhooksAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksMaxFieldsSelection;
        include?: CustomerProcessedWebhooksMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksMinFieldsSelection;
        include?: CustomerProcessedWebhooksMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksStddevFieldsSelection;
        include?: CustomerProcessedWebhooksStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksStddevPopFieldsSelection;
        include?: CustomerProcessedWebhooksStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksStddevSampFieldsSelection;
        include?: CustomerProcessedWebhooksStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksSumFieldsSelection;
        include?: CustomerProcessedWebhooksSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksVarPopFieldsSelection;
        include?: CustomerProcessedWebhooksVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksVarSampFieldsSelection;
        include?: CustomerProcessedWebhooksVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksVarianceFieldsSelection;
        include?: CustomerProcessedWebhooksVarianceFieldsSelection;
      };
}

export const includeCustomerProcessedWebhooksAggregateFields = <
  T extends CustomerProcessedWebhooksAggregateFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCustomerProcessedWebhooksAvgFields = <
  T extends CustomerProcessedWebhooksAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerProcessedWebhooksMaxFieldsSelection {
  event_id?: boolean | boolean;
  event_type?: boolean | boolean;
  id?: boolean | boolean;
  processed_at?: boolean | boolean;
}

export const includeCustomerProcessedWebhooksMaxFields = <
  T extends CustomerProcessedWebhooksMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerProcessedWebhooksMinFieldsSelection {
  event_id?: boolean | boolean;
  event_type?: boolean | boolean;
  id?: boolean | boolean;
  processed_at?: boolean | boolean;
}

export const includeCustomerProcessedWebhooksMinFields = <
  T extends CustomerProcessedWebhooksMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCustomerProcessedWebhooksMutationResponse = <
  T extends CustomerProcessedWebhooksMutationResponseSelection,
>(
  include: T,
) => include;

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

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

export const includeCustomerProcessedWebhooksStddevFields = <
  T extends CustomerProcessedWebhooksStddevFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCustomerProcessedWebhooksStddevPopFields = <
  T extends CustomerProcessedWebhooksStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCustomerProcessedWebhooksStddevSampFields = <
  T extends CustomerProcessedWebhooksStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCustomerProcessedWebhooksSumFields = <
  T extends CustomerProcessedWebhooksSumFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCustomerProcessedWebhooksVarPopFields = <
  T extends CustomerProcessedWebhooksVarPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCustomerProcessedWebhooksVarSampFields = <
  T extends CustomerProcessedWebhooksVarSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCustomerProcessedWebhooksVarianceFields = <
  T extends CustomerProcessedWebhooksVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerRefundsSelection {
  acquirer_data?: boolean | boolean;
  amount?: boolean | boolean;
  batch_id?: boolean | boolean;
  created_at?: boolean | boolean;
  currency?: boolean | boolean;
  customer_payment?: boolean | boolean;
  external_refund_id?: boolean | boolean;
  id?: boolean | boolean;
  notes?: boolean | boolean;
  payment_id?: boolean | boolean;
  receipt?: boolean | boolean;
  speed_processed?: boolean | boolean;
  speed_requested?: boolean | boolean;
  status?: boolean | boolean;
}

export const includeCustomerRefunds = <T extends CustomerRefundsSelection>(
  include: T,
) => include;

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

export interface CustomerRefundsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CustomerRefundsAggregateFieldsSelection;
        include?: CustomerRefundsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCustomerRefundsAggregate = <
  T extends CustomerRefundsAggregateSelection,
>(
  include: T,
) => include;

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

export interface CustomerRefundsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: CustomerRefundsAvgFieldsSelection;
        include?: CustomerRefundsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CustomerRefundsMaxFieldsSelection;
        include?: CustomerRefundsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CustomerRefundsMinFieldsSelection;
        include?: CustomerRefundsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: CustomerRefundsStddevFieldsSelection;
        include?: CustomerRefundsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: CustomerRefundsStddevPopFieldsSelection;
        include?: CustomerRefundsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: CustomerRefundsStddevSampFieldsSelection;
        include?: CustomerRefundsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: CustomerRefundsSumFieldsSelection;
        include?: CustomerRefundsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: CustomerRefundsVarPopFieldsSelection;
        include?: CustomerRefundsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: CustomerRefundsVarSampFieldsSelection;
        include?: CustomerRefundsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: CustomerRefundsVarianceFieldsSelection;
        include?: CustomerRefundsVarianceFieldsSelection;
      };
}

export const includeCustomerRefundsAggregateFields = <
  T extends CustomerRefundsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerRefundsAvgFieldsSelection {
  amount?: boolean | boolean;
  id?: boolean | boolean;
  payment_id?: boolean | boolean;
}

export const includeCustomerRefundsAvgFields = <
  T extends CustomerRefundsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerRefundsMaxFieldsSelection {
  amount?: boolean | boolean;
  batch_id?: boolean | boolean;
  created_at?: boolean | boolean;
  currency?: boolean | boolean;
  external_refund_id?: boolean | boolean;
  id?: boolean | boolean;
  payment_id?: boolean | boolean;
  receipt?: boolean | boolean;
  speed_processed?: boolean | boolean;
  speed_requested?: boolean | boolean;
  status?: boolean | boolean;
}

export const includeCustomerRefundsMaxFields = <
  T extends CustomerRefundsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerRefundsMinFieldsSelection {
  amount?: boolean | boolean;
  batch_id?: boolean | boolean;
  created_at?: boolean | boolean;
  currency?: boolean | boolean;
  external_refund_id?: boolean | boolean;
  id?: boolean | boolean;
  payment_id?: boolean | boolean;
  receipt?: boolean | boolean;
  speed_processed?: boolean | boolean;
  speed_requested?: boolean | boolean;
  status?: boolean | boolean;
}

export const includeCustomerRefundsMinFields = <
  T extends CustomerRefundsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCustomerRefundsMutationResponse = <
  T extends CustomerRefundsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface CustomerRefundsStddevFieldsSelection {
  amount?: boolean | boolean;
  id?: boolean | boolean;
  payment_id?: boolean | boolean;
}

export const includeCustomerRefundsStddevFields = <
  T extends CustomerRefundsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerRefundsStddevPopFieldsSelection {
  amount?: boolean | boolean;
  id?: boolean | boolean;
  payment_id?: boolean | boolean;
}

export const includeCustomerRefundsStddevPopFields = <
  T extends CustomerRefundsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerRefundsStddevSampFieldsSelection {
  amount?: boolean | boolean;
  id?: boolean | boolean;
  payment_id?: boolean | boolean;
}

export const includeCustomerRefundsStddevSampFields = <
  T extends CustomerRefundsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerRefundsSumFieldsSelection {
  amount?: boolean | boolean;
  id?: boolean | boolean;
  payment_id?: boolean | boolean;
}

export const includeCustomerRefundsSumFields = <
  T extends CustomerRefundsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerRefundsVarPopFieldsSelection {
  amount?: boolean | boolean;
  id?: boolean | boolean;
  payment_id?: boolean | boolean;
}

export const includeCustomerRefundsVarPopFields = <
  T extends CustomerRefundsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerRefundsVarSampFieldsSelection {
  amount?: boolean | boolean;
  id?: boolean | boolean;
  payment_id?: boolean | boolean;
}

export const includeCustomerRefundsVarSampFields = <
  T extends CustomerRefundsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerRefundsVarianceFieldsSelection {
  amount?: boolean | boolean;
  id?: boolean | boolean;
  payment_id?: boolean | boolean;
}

export const includeCustomerRefundsVarianceFields = <
  T extends CustomerRefundsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionPlansSelection {
  annual_amount?: boolean | boolean;
  created_at?: boolean | boolean;
  currency?: boolean | boolean;
  customer_subscriptions?: boolean | boolean;
  customer_subscriptions_aggregate?: boolean | boolean;
  description?: boolean | boolean;
  external_plan_id?: boolean | boolean;
  features?: boolean | boolean;
  id?: boolean | boolean;
  interval?: boolean | boolean;
  interval_type?: boolean | boolean;
  is_active?: boolean | boolean;
  monthly_amount?: boolean | boolean;
  name?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeCustomerSubscriptionPlans = <
  T extends CustomerSubscriptionPlansSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionPlansAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansAggregateFieldsSelection;
        include?: CustomerSubscriptionPlansAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCustomerSubscriptionPlansAggregate = <
  T extends CustomerSubscriptionPlansAggregateSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionPlansAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansAvgFieldsSelection;
        include?: CustomerSubscriptionPlansAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansMaxFieldsSelection;
        include?: CustomerSubscriptionPlansMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansMinFieldsSelection;
        include?: CustomerSubscriptionPlansMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansStddevFieldsSelection;
        include?: CustomerSubscriptionPlansStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansStddevPopFieldsSelection;
        include?: CustomerSubscriptionPlansStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansStddevSampFieldsSelection;
        include?: CustomerSubscriptionPlansStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansSumFieldsSelection;
        include?: CustomerSubscriptionPlansSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansVarPopFieldsSelection;
        include?: CustomerSubscriptionPlansVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansVarSampFieldsSelection;
        include?: CustomerSubscriptionPlansVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansVarianceFieldsSelection;
        include?: CustomerSubscriptionPlansVarianceFieldsSelection;
      };
}

export const includeCustomerSubscriptionPlansAggregateFields = <
  T extends CustomerSubscriptionPlansAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionPlansAvgFieldsSelection {
  annual_amount?: boolean | boolean;
  id?: boolean | boolean;
  interval?: boolean | boolean;
  monthly_amount?: boolean | boolean;
}

export const includeCustomerSubscriptionPlansAvgFields = <
  T extends CustomerSubscriptionPlansAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionPlansMaxFieldsSelection {
  annual_amount?: boolean | boolean;
  created_at?: boolean | boolean;
  currency?: boolean | boolean;
  description?: boolean | boolean;
  external_plan_id?: boolean | boolean;
  id?: boolean | boolean;
  interval?: boolean | boolean;
  interval_type?: boolean | boolean;
  monthly_amount?: boolean | boolean;
  name?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeCustomerSubscriptionPlansMaxFields = <
  T extends CustomerSubscriptionPlansMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionPlansMinFieldsSelection {
  annual_amount?: boolean | boolean;
  created_at?: boolean | boolean;
  currency?: boolean | boolean;
  description?: boolean | boolean;
  external_plan_id?: boolean | boolean;
  id?: boolean | boolean;
  interval?: boolean | boolean;
  interval_type?: boolean | boolean;
  monthly_amount?: boolean | boolean;
  name?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeCustomerSubscriptionPlansMinFields = <
  T extends CustomerSubscriptionPlansMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCustomerSubscriptionPlansMutationResponse = <
  T extends CustomerSubscriptionPlansMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionPlansStddevFieldsSelection {
  annual_amount?: boolean | boolean;
  id?: boolean | boolean;
  interval?: boolean | boolean;
  monthly_amount?: boolean | boolean;
}

export const includeCustomerSubscriptionPlansStddevFields = <
  T extends CustomerSubscriptionPlansStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionPlansStddevPopFieldsSelection {
  annual_amount?: boolean | boolean;
  id?: boolean | boolean;
  interval?: boolean | boolean;
  monthly_amount?: boolean | boolean;
}

export const includeCustomerSubscriptionPlansStddevPopFields = <
  T extends CustomerSubscriptionPlansStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionPlansStddevSampFieldsSelection {
  annual_amount?: boolean | boolean;
  id?: boolean | boolean;
  interval?: boolean | boolean;
  monthly_amount?: boolean | boolean;
}

export const includeCustomerSubscriptionPlansStddevSampFields = <
  T extends CustomerSubscriptionPlansStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionPlansSumFieldsSelection {
  annual_amount?: boolean | boolean;
  id?: boolean | boolean;
  interval?: boolean | boolean;
  monthly_amount?: boolean | boolean;
}

export const includeCustomerSubscriptionPlansSumFields = <
  T extends CustomerSubscriptionPlansSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionPlansVarPopFieldsSelection {
  annual_amount?: boolean | boolean;
  id?: boolean | boolean;
  interval?: boolean | boolean;
  monthly_amount?: boolean | boolean;
}

export const includeCustomerSubscriptionPlansVarPopFields = <
  T extends CustomerSubscriptionPlansVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionPlansVarSampFieldsSelection {
  annual_amount?: boolean | boolean;
  id?: boolean | boolean;
  interval?: boolean | boolean;
  monthly_amount?: boolean | boolean;
}

export const includeCustomerSubscriptionPlansVarSampFields = <
  T extends CustomerSubscriptionPlansVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionPlansVarianceFieldsSelection {
  annual_amount?: boolean | boolean;
  id?: boolean | boolean;
  interval?: boolean | boolean;
  monthly_amount?: boolean | boolean;
}

export const includeCustomerSubscriptionPlansVarianceFields = <
  T extends CustomerSubscriptionPlansVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionsSelection {
  auth_attempts?: boolean | boolean;
  cancel_at_period_end?: boolean | boolean;
  cancel_initiated_by?: boolean | boolean;
  change_scheduled_at?: boolean | boolean;
  charge_at?: boolean | boolean;
  created_at?: boolean | boolean;
  current_end?: boolean | boolean;
  current_start?: boolean | boolean;
  customer_notify?: boolean | boolean;
  customer_payments?: boolean | boolean;
  customer_payments_aggregate?: boolean | boolean;
  customer_subscription_plan?: boolean | boolean;
  end_at?: boolean | boolean;
  ended_at?: boolean | boolean;
  expire_by?: boolean | boolean;
  external_subscription_id?: boolean | boolean;
  has_scheduled_changes?: boolean | boolean;
  id?: boolean | boolean;
  notes?: boolean | boolean;
  offer_id?: boolean | boolean;
  paid_count?: boolean | boolean;
  pause_initiated_by?: boolean | boolean;
  payment_provider?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  plan_id?: boolean | boolean;
  quantity?: boolean | boolean;
  remaining_count?: boolean | boolean;
  short_url?: boolean | boolean;
  source?: boolean | boolean;
  start_at?: boolean | boolean;
  status?: boolean | boolean;
  total_count?: boolean | boolean;
  type?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
  user_profile?: boolean | boolean;
}

export const includeCustomerSubscriptions = <
  T extends CustomerSubscriptionsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: CustomerSubscriptionsAggregateFieldsSelection;
        include?: CustomerSubscriptionsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeCustomerSubscriptionsAggregate = <
  T extends CustomerSubscriptionsAggregateSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: CustomerSubscriptionsAvgFieldsSelection;
        include?: CustomerSubscriptionsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: CustomerSubscriptionsMaxFieldsSelection;
        include?: CustomerSubscriptionsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: CustomerSubscriptionsMinFieldsSelection;
        include?: CustomerSubscriptionsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: CustomerSubscriptionsStddevFieldsSelection;
        include?: CustomerSubscriptionsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: CustomerSubscriptionsStddevPopFieldsSelection;
        include?: CustomerSubscriptionsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: CustomerSubscriptionsStddevSampFieldsSelection;
        include?: CustomerSubscriptionsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: CustomerSubscriptionsSumFieldsSelection;
        include?: CustomerSubscriptionsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: CustomerSubscriptionsVarPopFieldsSelection;
        include?: CustomerSubscriptionsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: CustomerSubscriptionsVarSampFieldsSelection;
        include?: CustomerSubscriptionsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: CustomerSubscriptionsVarianceFieldsSelection;
        include?: CustomerSubscriptionsVarianceFieldsSelection;
      };
}

export const includeCustomerSubscriptionsAggregateFields = <
  T extends CustomerSubscriptionsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionsAvgFieldsSelection {
  auth_attempts?: boolean | boolean;
  id?: boolean | boolean;
  paid_count?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  plan_id?: boolean | boolean;
  quantity?: boolean | boolean;
  remaining_count?: boolean | boolean;
  total_count?: boolean | boolean;
  type?: boolean | boolean;
}

export const includeCustomerSubscriptionsAvgFields = <
  T extends CustomerSubscriptionsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionsMaxFieldsSelection {
  auth_attempts?: boolean | boolean;
  cancel_initiated_by?: boolean | boolean;
  change_scheduled_at?: boolean | boolean;
  charge_at?: boolean | boolean;
  created_at?: boolean | boolean;
  current_end?: boolean | boolean;
  current_start?: boolean | boolean;
  end_at?: boolean | boolean;
  ended_at?: boolean | boolean;
  expire_by?: boolean | boolean;
  external_subscription_id?: boolean | boolean;
  id?: boolean | boolean;
  offer_id?: boolean | boolean;
  paid_count?: boolean | boolean;
  pause_initiated_by?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  plan_id?: boolean | boolean;
  quantity?: boolean | boolean;
  remaining_count?: boolean | boolean;
  short_url?: boolean | boolean;
  source?: boolean | boolean;
  start_at?: boolean | boolean;
  status?: boolean | boolean;
  total_count?: boolean | boolean;
  type?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeCustomerSubscriptionsMaxFields = <
  T extends CustomerSubscriptionsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionsMinFieldsSelection {
  auth_attempts?: boolean | boolean;
  cancel_initiated_by?: boolean | boolean;
  change_scheduled_at?: boolean | boolean;
  charge_at?: boolean | boolean;
  created_at?: boolean | boolean;
  current_end?: boolean | boolean;
  current_start?: boolean | boolean;
  end_at?: boolean | boolean;
  ended_at?: boolean | boolean;
  expire_by?: boolean | boolean;
  external_subscription_id?: boolean | boolean;
  id?: boolean | boolean;
  offer_id?: boolean | boolean;
  paid_count?: boolean | boolean;
  pause_initiated_by?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  plan_id?: boolean | boolean;
  quantity?: boolean | boolean;
  remaining_count?: boolean | boolean;
  short_url?: boolean | boolean;
  source?: boolean | boolean;
  start_at?: boolean | boolean;
  status?: boolean | boolean;
  total_count?: boolean | boolean;
  type?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeCustomerSubscriptionsMinFields = <
  T extends CustomerSubscriptionsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeCustomerSubscriptionsMutationResponse = <
  T extends CustomerSubscriptionsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionsStddevFieldsSelection {
  auth_attempts?: boolean | boolean;
  id?: boolean | boolean;
  paid_count?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  plan_id?: boolean | boolean;
  quantity?: boolean | boolean;
  remaining_count?: boolean | boolean;
  total_count?: boolean | boolean;
  type?: boolean | boolean;
}

export const includeCustomerSubscriptionsStddevFields = <
  T extends CustomerSubscriptionsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionsStddevPopFieldsSelection {
  auth_attempts?: boolean | boolean;
  id?: boolean | boolean;
  paid_count?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  plan_id?: boolean | boolean;
  quantity?: boolean | boolean;
  remaining_count?: boolean | boolean;
  total_count?: boolean | boolean;
  type?: boolean | boolean;
}

export const includeCustomerSubscriptionsStddevPopFields = <
  T extends CustomerSubscriptionsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionsStddevSampFieldsSelection {
  auth_attempts?: boolean | boolean;
  id?: boolean | boolean;
  paid_count?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  plan_id?: boolean | boolean;
  quantity?: boolean | boolean;
  remaining_count?: boolean | boolean;
  total_count?: boolean | boolean;
  type?: boolean | boolean;
}

export const includeCustomerSubscriptionsStddevSampFields = <
  T extends CustomerSubscriptionsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionsSumFieldsSelection {
  auth_attempts?: boolean | boolean;
  id?: boolean | boolean;
  paid_count?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  plan_id?: boolean | boolean;
  quantity?: boolean | boolean;
  remaining_count?: boolean | boolean;
  total_count?: boolean | boolean;
  type?: boolean | boolean;
}

export const includeCustomerSubscriptionsSumFields = <
  T extends CustomerSubscriptionsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionsVarPopFieldsSelection {
  auth_attempts?: boolean | boolean;
  id?: boolean | boolean;
  paid_count?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  plan_id?: boolean | boolean;
  quantity?: boolean | boolean;
  remaining_count?: boolean | boolean;
  total_count?: boolean | boolean;
  type?: boolean | boolean;
}

export const includeCustomerSubscriptionsVarPopFields = <
  T extends CustomerSubscriptionsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionsVarSampFieldsSelection {
  auth_attempts?: boolean | boolean;
  id?: boolean | boolean;
  paid_count?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  plan_id?: boolean | boolean;
  quantity?: boolean | boolean;
  remaining_count?: boolean | boolean;
  total_count?: boolean | boolean;
  type?: boolean | boolean;
}

export const includeCustomerSubscriptionsVarSampFields = <
  T extends CustomerSubscriptionsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface CustomerSubscriptionsVarianceFieldsSelection {
  auth_attempts?: boolean | boolean;
  id?: boolean | boolean;
  paid_count?: boolean | boolean;
  payment_provider_id?: boolean | boolean;
  plan_id?: boolean | boolean;
  quantity?: boolean | boolean;
  remaining_count?: boolean | boolean;
  total_count?: boolean | boolean;
  type?: boolean | boolean;
}

export const includeCustomerSubscriptionsVarianceFields = <
  T extends CustomerSubscriptionsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface EmbeddingReviewsSelection {
  agent_review?: boolean | boolean;
  created_at?: boolean | boolean;
  human_review?: boolean | boolean;
  id?: boolean | boolean;
  notes?: boolean | boolean;
  research_embeddings?: boolean | boolean;
  research_embeddings_aggregate?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeEmbeddingReviews = <T extends EmbeddingReviewsSelection>(
  include: T,
) => include;

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

export interface EmbeddingReviewsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: EmbeddingReviewsAggregateFieldsSelection;
        include?: EmbeddingReviewsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeEmbeddingReviewsAggregate = <
  T extends EmbeddingReviewsAggregateSelection,
>(
  include: T,
) => include;

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

export interface EmbeddingReviewsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: EmbeddingReviewsAvgFieldsSelection;
        include?: EmbeddingReviewsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: EmbeddingReviewsMaxFieldsSelection;
        include?: EmbeddingReviewsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: EmbeddingReviewsMinFieldsSelection;
        include?: EmbeddingReviewsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: EmbeddingReviewsStddevFieldsSelection;
        include?: EmbeddingReviewsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: EmbeddingReviewsStddevPopFieldsSelection;
        include?: EmbeddingReviewsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: EmbeddingReviewsStddevSampFieldsSelection;
        include?: EmbeddingReviewsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: EmbeddingReviewsSumFieldsSelection;
        include?: EmbeddingReviewsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: EmbeddingReviewsVarPopFieldsSelection;
        include?: EmbeddingReviewsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: EmbeddingReviewsVarSampFieldsSelection;
        include?: EmbeddingReviewsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: EmbeddingReviewsVarianceFieldsSelection;
        include?: EmbeddingReviewsVarianceFieldsSelection;
      };
}

export const includeEmbeddingReviewsAggregateFields = <
  T extends EmbeddingReviewsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeEmbeddingReviewsAvgFields = <
  T extends EmbeddingReviewsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface EmbeddingReviewsMaxFieldsSelection {
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  notes?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeEmbeddingReviewsMaxFields = <
  T extends EmbeddingReviewsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface EmbeddingReviewsMinFieldsSelection {
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  notes?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeEmbeddingReviewsMinFields = <
  T extends EmbeddingReviewsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeEmbeddingReviewsMutationResponse = <
  T extends EmbeddingReviewsMutationResponseSelection,
>(
  include: T,
) => include;

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

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

export const includeEmbeddingReviewsStddevFields = <
  T extends EmbeddingReviewsStddevFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeEmbeddingReviewsStddevPopFields = <
  T extends EmbeddingReviewsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeEmbeddingReviewsStddevSampFields = <
  T extends EmbeddingReviewsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeEmbeddingReviewsSumFields = <
  T extends EmbeddingReviewsSumFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeEmbeddingReviewsVarPopFields = <
  T extends EmbeddingReviewsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeEmbeddingReviewsVarSampFields = <
  T extends EmbeddingReviewsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeEmbeddingReviewsVarianceFields = <
  T extends EmbeddingReviewsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorCorrelationsSelection {
  avg_time_difference?: boolean | boolean;
  correlation_count?: boolean | boolean;
  id?: boolean | boolean;
  source_pattern?: boolean | boolean;
  source_service?: boolean | boolean;
  target_pattern?: boolean | boolean;
  target_service?: boolean | boolean;
}

export const includeErrorCorrelations = <T extends ErrorCorrelationsSelection>(
  include: T,
) => include;

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

export interface ErrorCorrelationsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ErrorCorrelationsAggregateFieldsSelection;
        include?: ErrorCorrelationsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeErrorCorrelationsAggregate = <
  T extends ErrorCorrelationsAggregateSelection,
>(
  include: T,
) => include;

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

export interface ErrorCorrelationsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ErrorCorrelationsAvgFieldsSelection;
        include?: ErrorCorrelationsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ErrorCorrelationsMaxFieldsSelection;
        include?: ErrorCorrelationsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ErrorCorrelationsMinFieldsSelection;
        include?: ErrorCorrelationsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ErrorCorrelationsStddevFieldsSelection;
        include?: ErrorCorrelationsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ErrorCorrelationsStddevPopFieldsSelection;
        include?: ErrorCorrelationsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ErrorCorrelationsStddevSampFieldsSelection;
        include?: ErrorCorrelationsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ErrorCorrelationsSumFieldsSelection;
        include?: ErrorCorrelationsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ErrorCorrelationsVarPopFieldsSelection;
        include?: ErrorCorrelationsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ErrorCorrelationsVarSampFieldsSelection;
        include?: ErrorCorrelationsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ErrorCorrelationsVarianceFieldsSelection;
        include?: ErrorCorrelationsVarianceFieldsSelection;
      };
}

export const includeErrorCorrelationsAggregateFields = <
  T extends ErrorCorrelationsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorCorrelationsAvgFieldsSelection {
  avg_time_difference?: boolean | boolean;
  correlation_count?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeErrorCorrelationsAvgFields = <
  T extends ErrorCorrelationsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorCorrelationsMaxFieldsSelection {
  avg_time_difference?: boolean | boolean;
  correlation_count?: boolean | boolean;
  id?: boolean | boolean;
  source_pattern?: boolean | boolean;
  source_service?: boolean | boolean;
  target_pattern?: boolean | boolean;
  target_service?: boolean | boolean;
}

export const includeErrorCorrelationsMaxFields = <
  T extends ErrorCorrelationsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorCorrelationsMinFieldsSelection {
  avg_time_difference?: boolean | boolean;
  correlation_count?: boolean | boolean;
  id?: boolean | boolean;
  source_pattern?: boolean | boolean;
  source_service?: boolean | boolean;
  target_pattern?: boolean | boolean;
  target_service?: boolean | boolean;
}

export const includeErrorCorrelationsMinFields = <
  T extends ErrorCorrelationsMinFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorCorrelationsStddevFieldsSelection {
  avg_time_difference?: boolean | boolean;
  correlation_count?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeErrorCorrelationsStddevFields = <
  T extends ErrorCorrelationsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorCorrelationsStddevPopFieldsSelection {
  avg_time_difference?: boolean | boolean;
  correlation_count?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeErrorCorrelationsStddevPopFields = <
  T extends ErrorCorrelationsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorCorrelationsStddevSampFieldsSelection {
  avg_time_difference?: boolean | boolean;
  correlation_count?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeErrorCorrelationsStddevSampFields = <
  T extends ErrorCorrelationsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorCorrelationsSumFieldsSelection {
  avg_time_difference?: boolean | boolean;
  correlation_count?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeErrorCorrelationsSumFields = <
  T extends ErrorCorrelationsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorCorrelationsVarPopFieldsSelection {
  avg_time_difference?: boolean | boolean;
  correlation_count?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeErrorCorrelationsVarPopFields = <
  T extends ErrorCorrelationsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorCorrelationsVarSampFieldsSelection {
  avg_time_difference?: boolean | boolean;
  correlation_count?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeErrorCorrelationsVarSampFields = <
  T extends ErrorCorrelationsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorCorrelationsVarianceFieldsSelection {
  avg_time_difference?: boolean | boolean;
  correlation_count?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeErrorCorrelationsVarianceFields = <
  T extends ErrorCorrelationsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorFrequencySelection {
  error_count?: boolean | boolean;
  error_type?: boolean | boolean;
  service_name?: boolean | boolean;
  severity?: boolean | boolean;
  time_bucket?: boolean | boolean;
}

export const includeErrorFrequency = <T extends ErrorFrequencySelection>(
  include: T,
) => include;

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

export interface ErrorFrequencyAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ErrorFrequencyAggregateFieldsSelection;
        include?: ErrorFrequencyAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeErrorFrequencyAggregate = <
  T extends ErrorFrequencyAggregateSelection,
>(
  include: T,
) => include;

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

export interface ErrorFrequencyAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ErrorFrequencyAvgFieldsSelection;
        include?: ErrorFrequencyAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ErrorFrequencyMaxFieldsSelection;
        include?: ErrorFrequencyMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ErrorFrequencyMinFieldsSelection;
        include?: ErrorFrequencyMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ErrorFrequencyStddevFieldsSelection;
        include?: ErrorFrequencyStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ErrorFrequencyStddevPopFieldsSelection;
        include?: ErrorFrequencyStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ErrorFrequencyStddevSampFieldsSelection;
        include?: ErrorFrequencyStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ErrorFrequencySumFieldsSelection;
        include?: ErrorFrequencySumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ErrorFrequencyVarPopFieldsSelection;
        include?: ErrorFrequencyVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ErrorFrequencyVarSampFieldsSelection;
        include?: ErrorFrequencyVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ErrorFrequencyVarianceFieldsSelection;
        include?: ErrorFrequencyVarianceFieldsSelection;
      };
}

export const includeErrorFrequencyAggregateFields = <
  T extends ErrorFrequencyAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorFrequencyAvgFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorFrequencyAvgFields = <
  T extends ErrorFrequencyAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorFrequencyMaxFieldsSelection {
  error_count?: boolean | boolean;
  error_type?: boolean | boolean;
  service_name?: boolean | boolean;
  severity?: boolean | boolean;
  time_bucket?: boolean | boolean;
}

export const includeErrorFrequencyMaxFields = <
  T extends ErrorFrequencyMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorFrequencyMinFieldsSelection {
  error_count?: boolean | boolean;
  error_type?: boolean | boolean;
  service_name?: boolean | boolean;
  severity?: boolean | boolean;
  time_bucket?: boolean | boolean;
}

export const includeErrorFrequencyMinFields = <
  T extends ErrorFrequencyMinFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorFrequencyStddevFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorFrequencyStddevFields = <
  T extends ErrorFrequencyStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorFrequencyStddevPopFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorFrequencyStddevPopFields = <
  T extends ErrorFrequencyStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorFrequencyStddevSampFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorFrequencyStddevSampFields = <
  T extends ErrorFrequencyStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorFrequencySumFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorFrequencySumFields = <
  T extends ErrorFrequencySumFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorFrequencyVarPopFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorFrequencyVarPopFields = <
  T extends ErrorFrequencyVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorFrequencyVarSampFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorFrequencyVarSampFields = <
  T extends ErrorFrequencyVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorFrequencyVarianceFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorFrequencyVarianceFields = <
  T extends ErrorFrequencyVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorLogsSelection {
  context?: boolean | boolean;
  correlation_id?: boolean | boolean;
  created_at?: boolean | boolean;
  domain?: boolean | boolean;
  environment?: boolean | boolean;
  error_hash?: boolean | boolean;
  error_pattern?: boolean | boolean;
  error_type?: boolean | boolean;
  frequency_data?: boolean | boolean;
  github_repo?: boolean | boolean;
  id?: boolean | boolean;
  is_new_pattern?: boolean | boolean;
  message?: boolean | boolean;
  metadata?: boolean | boolean;
  related_errors?: boolean | boolean;
  request_id?: boolean | boolean;
  service_name?: boolean | boolean;
  severity?: boolean | boolean;
  stack_trace?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeErrorLogs = <T extends ErrorLogsSelection>(include: T) =>
  include;

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

export interface ErrorLogsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ErrorLogsAggregateFieldsSelection;
        include?: ErrorLogsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeErrorLogsAggregate = <
  T extends ErrorLogsAggregateSelection,
>(
  include: T,
) => include;

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

export interface ErrorLogsAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ErrorLogsMaxFieldsSelection;
        include?: ErrorLogsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ErrorLogsMinFieldsSelection;
        include?: ErrorLogsMinFieldsSelection;
      };
}

export const includeErrorLogsAggregateFields = <
  T extends ErrorLogsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorLogsMaxFieldsSelection {
  correlation_id?: boolean | boolean;
  created_at?: boolean | boolean;
  domain?: boolean | boolean;
  environment?: boolean | boolean;
  error_hash?: boolean | boolean;
  error_pattern?: boolean | boolean;
  error_type?: boolean | boolean;
  github_repo?: boolean | boolean;
  id?: boolean | boolean;
  message?: boolean | boolean;
  request_id?: boolean | boolean;
  service_name?: boolean | boolean;
  severity?: boolean | boolean;
  stack_trace?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeErrorLogsMaxFields = <
  T extends ErrorLogsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorLogsMinFieldsSelection {
  correlation_id?: boolean | boolean;
  created_at?: boolean | boolean;
  domain?: boolean | boolean;
  environment?: boolean | boolean;
  error_hash?: boolean | boolean;
  error_pattern?: boolean | boolean;
  error_type?: boolean | boolean;
  github_repo?: boolean | boolean;
  id?: boolean | boolean;
  message?: boolean | boolean;
  request_id?: boolean | boolean;
  service_name?: boolean | boolean;
  severity?: boolean | boolean;
  stack_trace?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeErrorLogsMinFields = <
  T extends ErrorLogsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeErrorLogsMutationResponse = <
  T extends ErrorLogsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface ErrorMetricsSelection {
  error_count?: boolean | boolean;
  error_type?: boolean | boolean;
  service_name?: boolean | boolean;
  severity?: boolean | boolean;
  time_bucket?: boolean | boolean;
}

export const includeErrorMetrics = <T extends ErrorMetricsSelection>(
  include: T,
) => include;

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

export interface ErrorMetricsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ErrorMetricsAggregateFieldsSelection;
        include?: ErrorMetricsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeErrorMetricsAggregate = <
  T extends ErrorMetricsAggregateSelection,
>(
  include: T,
) => include;

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

export interface ErrorMetricsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ErrorMetricsAvgFieldsSelection;
        include?: ErrorMetricsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ErrorMetricsMaxFieldsSelection;
        include?: ErrorMetricsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ErrorMetricsMinFieldsSelection;
        include?: ErrorMetricsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ErrorMetricsStddevFieldsSelection;
        include?: ErrorMetricsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ErrorMetricsStddevPopFieldsSelection;
        include?: ErrorMetricsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ErrorMetricsStddevSampFieldsSelection;
        include?: ErrorMetricsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ErrorMetricsSumFieldsSelection;
        include?: ErrorMetricsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ErrorMetricsVarPopFieldsSelection;
        include?: ErrorMetricsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ErrorMetricsVarSampFieldsSelection;
        include?: ErrorMetricsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ErrorMetricsVarianceFieldsSelection;
        include?: ErrorMetricsVarianceFieldsSelection;
      };
}

export const includeErrorMetricsAggregateFields = <
  T extends ErrorMetricsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorMetricsAvgFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorMetricsAvgFields = <
  T extends ErrorMetricsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorMetricsMaxFieldsSelection {
  error_count?: boolean | boolean;
  error_type?: boolean | boolean;
  service_name?: boolean | boolean;
  severity?: boolean | boolean;
  time_bucket?: boolean | boolean;
}

export const includeErrorMetricsMaxFields = <
  T extends ErrorMetricsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorMetricsMinFieldsSelection {
  error_count?: boolean | boolean;
  error_type?: boolean | boolean;
  service_name?: boolean | boolean;
  severity?: boolean | boolean;
  time_bucket?: boolean | boolean;
}

export const includeErrorMetricsMinFields = <
  T extends ErrorMetricsMinFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorMetricsStddevFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorMetricsStddevFields = <
  T extends ErrorMetricsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorMetricsStddevPopFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorMetricsStddevPopFields = <
  T extends ErrorMetricsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorMetricsStddevSampFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorMetricsStddevSampFields = <
  T extends ErrorMetricsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorMetricsSumFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorMetricsSumFields = <
  T extends ErrorMetricsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorMetricsVarPopFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorMetricsVarPopFields = <
  T extends ErrorMetricsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorMetricsVarSampFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorMetricsVarSampFields = <
  T extends ErrorMetricsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorMetricsVarianceFieldsSelection {
  error_count?: boolean | boolean;
}

export const includeErrorMetricsVarianceFields = <
  T extends ErrorMetricsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorPatternsSelection {
  contexts?: boolean | boolean;
  daily_frequency?: boolean | boolean;
  days_active?: boolean | boolean;
  error_hash?: boolean | boolean;
  error_pattern?: boolean | boolean;
  first_seen?: boolean | boolean;
  id?: boolean | boolean;
  is_new?: boolean | boolean;
  last_seen?: boolean | boolean;
  occurrence_count?: boolean | boolean;
  service_name?: boolean | boolean;
  severity_levels?: boolean | boolean;
}

export const includeErrorPatterns = <T extends ErrorPatternsSelection>(
  include: T,
) => include;

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

export interface ErrorPatternsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ErrorPatternsAggregateFieldsSelection;
        include?: ErrorPatternsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeErrorPatternsAggregate = <
  T extends ErrorPatternsAggregateSelection,
>(
  include: T,
) => include;

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

export interface ErrorPatternsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ErrorPatternsAvgFieldsSelection;
        include?: ErrorPatternsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ErrorPatternsMaxFieldsSelection;
        include?: ErrorPatternsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ErrorPatternsMinFieldsSelection;
        include?: ErrorPatternsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ErrorPatternsStddevFieldsSelection;
        include?: ErrorPatternsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ErrorPatternsStddevPopFieldsSelection;
        include?: ErrorPatternsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ErrorPatternsStddevSampFieldsSelection;
        include?: ErrorPatternsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ErrorPatternsSumFieldsSelection;
        include?: ErrorPatternsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ErrorPatternsVarPopFieldsSelection;
        include?: ErrorPatternsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ErrorPatternsVarSampFieldsSelection;
        include?: ErrorPatternsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ErrorPatternsVarianceFieldsSelection;
        include?: ErrorPatternsVarianceFieldsSelection;
      };
}

export const includeErrorPatternsAggregateFields = <
  T extends ErrorPatternsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorPatternsAvgFieldsSelection {
  daily_frequency?: boolean | boolean;
  days_active?: boolean | boolean;
  id?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeErrorPatternsAvgFields = <
  T extends ErrorPatternsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorPatternsMaxFieldsSelection {
  daily_frequency?: boolean | boolean;
  days_active?: boolean | boolean;
  error_hash?: boolean | boolean;
  error_pattern?: boolean | boolean;
  first_seen?: boolean | boolean;
  id?: boolean | boolean;
  last_seen?: boolean | boolean;
  occurrence_count?: boolean | boolean;
  service_name?: boolean | boolean;
  severity_levels?: boolean | boolean;
}

export const includeErrorPatternsMaxFields = <
  T extends ErrorPatternsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorPatternsMinFieldsSelection {
  daily_frequency?: boolean | boolean;
  days_active?: boolean | boolean;
  error_hash?: boolean | boolean;
  error_pattern?: boolean | boolean;
  first_seen?: boolean | boolean;
  id?: boolean | boolean;
  last_seen?: boolean | boolean;
  occurrence_count?: boolean | boolean;
  service_name?: boolean | boolean;
  severity_levels?: boolean | boolean;
}

export const includeErrorPatternsMinFields = <
  T extends ErrorPatternsMinFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorPatternsStddevFieldsSelection {
  daily_frequency?: boolean | boolean;
  days_active?: boolean | boolean;
  id?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeErrorPatternsStddevFields = <
  T extends ErrorPatternsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorPatternsStddevPopFieldsSelection {
  daily_frequency?: boolean | boolean;
  days_active?: boolean | boolean;
  id?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeErrorPatternsStddevPopFields = <
  T extends ErrorPatternsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorPatternsStddevSampFieldsSelection {
  daily_frequency?: boolean | boolean;
  days_active?: boolean | boolean;
  id?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeErrorPatternsStddevSampFields = <
  T extends ErrorPatternsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorPatternsSumFieldsSelection {
  daily_frequency?: boolean | boolean;
  days_active?: boolean | boolean;
  id?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeErrorPatternsSumFields = <
  T extends ErrorPatternsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorPatternsVarPopFieldsSelection {
  daily_frequency?: boolean | boolean;
  days_active?: boolean | boolean;
  id?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeErrorPatternsVarPopFields = <
  T extends ErrorPatternsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorPatternsVarSampFieldsSelection {
  daily_frequency?: boolean | boolean;
  days_active?: boolean | boolean;
  id?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeErrorPatternsVarSampFields = <
  T extends ErrorPatternsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorPatternsVarianceFieldsSelection {
  daily_frequency?: boolean | boolean;
  days_active?: boolean | boolean;
  id?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeErrorPatternsVarianceFields = <
  T extends ErrorPatternsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorStatsSelection {
  calls?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  mean_exec_time?: boolean | boolean;
  query?: boolean | boolean;
  queryid?: boolean | boolean;
  rows?: boolean | boolean;
  toplevel?: boolean | boolean;
}

export const includeErrorStats = <T extends ErrorStatsSelection>(include: T) =>
  include;

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

export interface ErrorStatsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ErrorStatsAggregateFieldsSelection;
        include?: ErrorStatsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeErrorStatsAggregate = <
  T extends ErrorStatsAggregateSelection,
>(
  include: T,
) => include;

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

export interface ErrorStatsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ErrorStatsAvgFieldsSelection;
        include?: ErrorStatsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ErrorStatsMaxFieldsSelection;
        include?: ErrorStatsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ErrorStatsMinFieldsSelection;
        include?: ErrorStatsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ErrorStatsStddevFieldsSelection;
        include?: ErrorStatsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ErrorStatsStddevPopFieldsSelection;
        include?: ErrorStatsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ErrorStatsStddevSampFieldsSelection;
        include?: ErrorStatsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ErrorStatsSumFieldsSelection;
        include?: ErrorStatsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ErrorStatsVarPopFieldsSelection;
        include?: ErrorStatsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ErrorStatsVarSampFieldsSelection;
        include?: ErrorStatsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ErrorStatsVarianceFieldsSelection;
        include?: ErrorStatsVarianceFieldsSelection;
      };
}

export const includeErrorStatsAggregateFields = <
  T extends ErrorStatsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorStatsAvgFieldsSelection {
  calls?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  mean_exec_time?: boolean | boolean;
  queryid?: boolean | boolean;
  rows?: boolean | boolean;
}

export const includeErrorStatsAvgFields = <
  T extends ErrorStatsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorStatsMaxFieldsSelection {
  calls?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  mean_exec_time?: boolean | boolean;
  query?: boolean | boolean;
  queryid?: boolean | boolean;
  rows?: boolean | boolean;
}

export const includeErrorStatsMaxFields = <
  T extends ErrorStatsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorStatsMinFieldsSelection {
  calls?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  mean_exec_time?: boolean | boolean;
  query?: boolean | boolean;
  queryid?: boolean | boolean;
  rows?: boolean | boolean;
}

export const includeErrorStatsMinFields = <
  T extends ErrorStatsMinFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorStatsStddevFieldsSelection {
  calls?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  mean_exec_time?: boolean | boolean;
  queryid?: boolean | boolean;
  rows?: boolean | boolean;
}

export const includeErrorStatsStddevFields = <
  T extends ErrorStatsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorStatsStddevPopFieldsSelection {
  calls?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  mean_exec_time?: boolean | boolean;
  queryid?: boolean | boolean;
  rows?: boolean | boolean;
}

export const includeErrorStatsStddevPopFields = <
  T extends ErrorStatsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorStatsStddevSampFieldsSelection {
  calls?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  mean_exec_time?: boolean | boolean;
  queryid?: boolean | boolean;
  rows?: boolean | boolean;
}

export const includeErrorStatsStddevSampFields = <
  T extends ErrorStatsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorStatsSumFieldsSelection {
  calls?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  mean_exec_time?: boolean | boolean;
  queryid?: boolean | boolean;
  rows?: boolean | boolean;
}

export const includeErrorStatsSumFields = <
  T extends ErrorStatsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorStatsVarPopFieldsSelection {
  calls?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  mean_exec_time?: boolean | boolean;
  queryid?: boolean | boolean;
  rows?: boolean | boolean;
}

export const includeErrorStatsVarPopFields = <
  T extends ErrorStatsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorStatsVarSampFieldsSelection {
  calls?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  mean_exec_time?: boolean | boolean;
  queryid?: boolean | boolean;
  rows?: boolean | boolean;
}

export const includeErrorStatsVarSampFields = <
  T extends ErrorStatsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ErrorStatsVarianceFieldsSelection {
  calls?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  mean_exec_time?: boolean | boolean;
  queryid?: boolean | boolean;
  rows?: boolean | boolean;
}

export const includeErrorStatsVarianceFields = <
  T extends ErrorStatsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureRequestsSelection {
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  downvotes?: boolean | boolean;
  engagement_score?: boolean | boolean;
  feature_votes?: boolean | boolean;
  feature_votes_aggregate?: boolean | boolean;
  id?: boolean | boolean;
  priority_score?: boolean | boolean;
  status?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeFeatureRequests = <T extends FeatureRequestsSelection>(
  include: T,
) => include;

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

export interface FeatureRequestsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: FeatureRequestsAggregateFieldsSelection;
        include?: FeatureRequestsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeFeatureRequestsAggregate = <
  T extends FeatureRequestsAggregateSelection,
>(
  include: T,
) => include;

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

export interface FeatureRequestsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: FeatureRequestsAvgFieldsSelection;
        include?: FeatureRequestsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: FeatureRequestsMaxFieldsSelection;
        include?: FeatureRequestsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: FeatureRequestsMinFieldsSelection;
        include?: FeatureRequestsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: FeatureRequestsStddevFieldsSelection;
        include?: FeatureRequestsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: FeatureRequestsStddevPopFieldsSelection;
        include?: FeatureRequestsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: FeatureRequestsStddevSampFieldsSelection;
        include?: FeatureRequestsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: FeatureRequestsSumFieldsSelection;
        include?: FeatureRequestsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: FeatureRequestsVarPopFieldsSelection;
        include?: FeatureRequestsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: FeatureRequestsVarSampFieldsSelection;
        include?: FeatureRequestsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: FeatureRequestsVarianceFieldsSelection;
        include?: FeatureRequestsVarianceFieldsSelection;
      };
}

export const includeFeatureRequestsAggregateFields = <
  T extends FeatureRequestsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureRequestsAvgFieldsSelection {
  downvotes?: boolean | boolean;
  engagement_score?: boolean | boolean;
  priority_score?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeFeatureRequestsAvgFields = <
  T extends FeatureRequestsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureRequestsMaxFieldsSelection {
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  downvotes?: boolean | boolean;
  engagement_score?: boolean | boolean;
  id?: boolean | boolean;
  priority_score?: boolean | boolean;
  status?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeFeatureRequestsMaxFields = <
  T extends FeatureRequestsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureRequestsMinFieldsSelection {
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  downvotes?: boolean | boolean;
  engagement_score?: boolean | boolean;
  id?: boolean | boolean;
  priority_score?: boolean | boolean;
  status?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeFeatureRequestsMinFields = <
  T extends FeatureRequestsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeFeatureRequestsMutationResponse = <
  T extends FeatureRequestsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface FeatureRequestsStddevFieldsSelection {
  downvotes?: boolean | boolean;
  engagement_score?: boolean | boolean;
  priority_score?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeFeatureRequestsStddevFields = <
  T extends FeatureRequestsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureRequestsStddevPopFieldsSelection {
  downvotes?: boolean | boolean;
  engagement_score?: boolean | boolean;
  priority_score?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeFeatureRequestsStddevPopFields = <
  T extends FeatureRequestsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureRequestsStddevSampFieldsSelection {
  downvotes?: boolean | boolean;
  engagement_score?: boolean | boolean;
  priority_score?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeFeatureRequestsStddevSampFields = <
  T extends FeatureRequestsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureRequestsSumFieldsSelection {
  downvotes?: boolean | boolean;
  engagement_score?: boolean | boolean;
  priority_score?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeFeatureRequestsSumFields = <
  T extends FeatureRequestsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureRequestsVarPopFieldsSelection {
  downvotes?: boolean | boolean;
  engagement_score?: boolean | boolean;
  priority_score?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeFeatureRequestsVarPopFields = <
  T extends FeatureRequestsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureRequestsVarSampFieldsSelection {
  downvotes?: boolean | boolean;
  engagement_score?: boolean | boolean;
  priority_score?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeFeatureRequestsVarSampFields = <
  T extends FeatureRequestsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureRequestsVarianceFieldsSelection {
  downvotes?: boolean | boolean;
  engagement_score?: boolean | boolean;
  priority_score?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeFeatureRequestsVarianceFields = <
  T extends FeatureRequestsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureVotesSelection {
  created_at?: boolean | boolean;
  feature_id?: boolean | boolean;
  feature_request?: boolean | boolean;
  feedback?: boolean | boolean;
  id?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
  vote_type?: boolean | boolean;
}

export const includeFeatureVotes = <T extends FeatureVotesSelection>(
  include: T,
) => include;

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

export interface FeatureVotesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: FeatureVotesAggregateFieldsSelection;
        include?: FeatureVotesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeFeatureVotesAggregate = <
  T extends FeatureVotesAggregateSelection,
>(
  include: T,
) => include;

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

export interface FeatureVotesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: FeatureVotesAvgFieldsSelection;
        include?: FeatureVotesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: FeatureVotesMaxFieldsSelection;
        include?: FeatureVotesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: FeatureVotesMinFieldsSelection;
        include?: FeatureVotesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: FeatureVotesStddevFieldsSelection;
        include?: FeatureVotesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: FeatureVotesStddevPopFieldsSelection;
        include?: FeatureVotesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: FeatureVotesStddevSampFieldsSelection;
        include?: FeatureVotesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: FeatureVotesSumFieldsSelection;
        include?: FeatureVotesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: FeatureVotesVarPopFieldsSelection;
        include?: FeatureVotesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: FeatureVotesVarSampFieldsSelection;
        include?: FeatureVotesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: FeatureVotesVarianceFieldsSelection;
        include?: FeatureVotesVarianceFieldsSelection;
      };
}

export const includeFeatureVotesAggregateFields = <
  T extends FeatureVotesAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureVotesAvgFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeFeatureVotesAvgFields = <
  T extends FeatureVotesAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureVotesMaxFieldsSelection {
  created_at?: boolean | boolean;
  feature_id?: boolean | boolean;
  feedback?: boolean | boolean;
  id?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
  vote_type?: boolean | boolean;
}

export const includeFeatureVotesMaxFields = <
  T extends FeatureVotesMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureVotesMinFieldsSelection {
  created_at?: boolean | boolean;
  feature_id?: boolean | boolean;
  feedback?: boolean | boolean;
  id?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
  vote_type?: boolean | boolean;
}

export const includeFeatureVotesMinFields = <
  T extends FeatureVotesMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeFeatureVotesMutationResponse = <
  T extends FeatureVotesMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface FeatureVotesStddevFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeFeatureVotesStddevFields = <
  T extends FeatureVotesStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureVotesStddevPopFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeFeatureVotesStddevPopFields = <
  T extends FeatureVotesStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureVotesStddevSampFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeFeatureVotesStddevSampFields = <
  T extends FeatureVotesStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureVotesSumFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeFeatureVotesSumFields = <
  T extends FeatureVotesSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureVotesVarPopFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeFeatureVotesVarPopFields = <
  T extends FeatureVotesVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureVotesVarSampFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeFeatureVotesVarSampFields = <
  T extends FeatureVotesVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeatureVotesVarianceFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeFeatureVotesVarianceFields = <
  T extends FeatureVotesVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedCategoriesSelection {
  category?:
    | boolean
    | {
        select?: CategoriesSelection;
        include?: CategoriesSelection;
      };
  category_id?: boolean | boolean;
  created_at?: boolean | boolean;
  feed?:
    | boolean
    | {
        select?: FeedsSelection;
        include?: FeedsSelection;
      };
  feed_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedCategories = <T extends FeedCategoriesSelection>(
  include: T,
) => include;

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

export interface FeedCategoriesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: FeedCategoriesAggregateFieldsSelection;
        include?: FeedCategoriesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeFeedCategoriesAggregate = <
  T extends FeedCategoriesAggregateSelection,
>(
  include: T,
) => include;

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

export interface FeedCategoriesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: FeedCategoriesAvgFieldsSelection;
        include?: FeedCategoriesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: FeedCategoriesMaxFieldsSelection;
        include?: FeedCategoriesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: FeedCategoriesMinFieldsSelection;
        include?: FeedCategoriesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: FeedCategoriesStddevFieldsSelection;
        include?: FeedCategoriesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: FeedCategoriesStddevPopFieldsSelection;
        include?: FeedCategoriesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: FeedCategoriesStddevSampFieldsSelection;
        include?: FeedCategoriesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: FeedCategoriesSumFieldsSelection;
        include?: FeedCategoriesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: FeedCategoriesVarPopFieldsSelection;
        include?: FeedCategoriesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: FeedCategoriesVarSampFieldsSelection;
        include?: FeedCategoriesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: FeedCategoriesVarianceFieldsSelection;
        include?: FeedCategoriesVarianceFieldsSelection;
      };
}

export const includeFeedCategoriesAggregateFields = <
  T extends FeedCategoriesAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedCategoriesAvgFieldsSelection {
  category_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedCategoriesAvgFields = <
  T extends FeedCategoriesAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedCategoriesMaxFieldsSelection {
  category_id?: boolean | boolean;
  created_at?: boolean | boolean;
  feed_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedCategoriesMaxFields = <
  T extends FeedCategoriesMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedCategoriesMinFieldsSelection {
  category_id?: boolean | boolean;
  created_at?: boolean | boolean;
  feed_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedCategoriesMinFields = <
  T extends FeedCategoriesMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeFeedCategoriesMutationResponse = <
  T extends FeedCategoriesMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface FeedCategoriesStddevFieldsSelection {
  category_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedCategoriesStddevFields = <
  T extends FeedCategoriesStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedCategoriesStddevPopFieldsSelection {
  category_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedCategoriesStddevPopFields = <
  T extends FeedCategoriesStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedCategoriesStddevSampFieldsSelection {
  category_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedCategoriesStddevSampFields = <
  T extends FeedCategoriesStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedCategoriesSumFieldsSelection {
  category_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedCategoriesSumFields = <
  T extends FeedCategoriesSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedCategoriesVarPopFieldsSelection {
  category_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedCategoriesVarPopFields = <
  T extends FeedCategoriesVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedCategoriesVarSampFieldsSelection {
  category_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedCategoriesVarSampFields = <
  T extends FeedCategoriesVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedCategoriesVarianceFieldsSelection {
  category_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedCategoriesVarianceFields = <
  T extends FeedCategoriesVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedSourcesSelection {
  content_source?:
    | boolean
    | {
        select?: ContentSourcesSelection;
        include?: ContentSourcesSelection;
      };
  content_source_id?: boolean | boolean;
  created_at?: boolean | boolean;
  feed?:
    | boolean
    | {
        select?: FeedsSelection;
        include?: FeedsSelection;
      };
  feed_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedSources = <T extends FeedSourcesSelection>(
  include: T,
) => include;

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

export interface FeedSourcesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: FeedSourcesAggregateFieldsSelection;
        include?: FeedSourcesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeFeedSourcesAggregate = <
  T extends FeedSourcesAggregateSelection,
>(
  include: T,
) => include;

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

export interface FeedSourcesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: FeedSourcesAvgFieldsSelection;
        include?: FeedSourcesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: FeedSourcesMaxFieldsSelection;
        include?: FeedSourcesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: FeedSourcesMinFieldsSelection;
        include?: FeedSourcesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: FeedSourcesStddevFieldsSelection;
        include?: FeedSourcesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: FeedSourcesStddevPopFieldsSelection;
        include?: FeedSourcesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: FeedSourcesStddevSampFieldsSelection;
        include?: FeedSourcesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: FeedSourcesSumFieldsSelection;
        include?: FeedSourcesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: FeedSourcesVarPopFieldsSelection;
        include?: FeedSourcesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: FeedSourcesVarSampFieldsSelection;
        include?: FeedSourcesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: FeedSourcesVarianceFieldsSelection;
        include?: FeedSourcesVarianceFieldsSelection;
      };
}

export const includeFeedSourcesAggregateFields = <
  T extends FeedSourcesAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedSourcesAvgFieldsSelection {
  content_source_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedSourcesAvgFields = <
  T extends FeedSourcesAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedSourcesMaxFieldsSelection {
  content_source_id?: boolean | boolean;
  created_at?: boolean | boolean;
  feed_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedSourcesMaxFields = <
  T extends FeedSourcesMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedSourcesMinFieldsSelection {
  content_source_id?: boolean | boolean;
  created_at?: boolean | boolean;
  feed_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedSourcesMinFields = <
  T extends FeedSourcesMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeFeedSourcesMutationResponse = <
  T extends FeedSourcesMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface FeedSourcesStddevFieldsSelection {
  content_source_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedSourcesStddevFields = <
  T extends FeedSourcesStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedSourcesStddevPopFieldsSelection {
  content_source_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedSourcesStddevPopFields = <
  T extends FeedSourcesStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedSourcesStddevSampFieldsSelection {
  content_source_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedSourcesStddevSampFields = <
  T extends FeedSourcesStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedSourcesSumFieldsSelection {
  content_source_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedSourcesSumFields = <
  T extends FeedSourcesSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedSourcesVarPopFieldsSelection {
  content_source_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedSourcesVarPopFields = <
  T extends FeedSourcesVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedSourcesVarSampFieldsSelection {
  content_source_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedSourcesVarSampFields = <
  T extends FeedSourcesVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedSourcesVarianceFieldsSelection {
  content_source_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeFeedSourcesVarianceFields = <
  T extends FeedSourcesVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedbacksSelection {
  created_at?: boolean | boolean;
  device_info?: boolean | boolean;
  feedback_status?: boolean | boolean;
  feedback_type?: boolean | boolean;
  id?: boolean | boolean;
  message?: boolean | boolean;
  page_identifier?: boolean | boolean;
  rating?: boolean | boolean;
  resolution_comment?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
  user_profile?:
    | boolean
    | {
        select?: UserProfilesSelection;
        include?: UserProfilesSelection;
      };
}

export const includeFeedbacks = <T extends FeedbacksSelection>(include: T) =>
  include;

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

export interface FeedbacksAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: FeedbacksAggregateFieldsSelection;
        include?: FeedbacksAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeFeedbacksAggregate = <
  T extends FeedbacksAggregateSelection,
>(
  include: T,
) => include;

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

export interface FeedbacksAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: FeedbacksAvgFieldsSelection;
        include?: FeedbacksAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: FeedbacksMaxFieldsSelection;
        include?: FeedbacksMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: FeedbacksMinFieldsSelection;
        include?: FeedbacksMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: FeedbacksStddevFieldsSelection;
        include?: FeedbacksStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: FeedbacksStddevPopFieldsSelection;
        include?: FeedbacksStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: FeedbacksStddevSampFieldsSelection;
        include?: FeedbacksStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: FeedbacksSumFieldsSelection;
        include?: FeedbacksSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: FeedbacksVarPopFieldsSelection;
        include?: FeedbacksVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: FeedbacksVarSampFieldsSelection;
        include?: FeedbacksVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: FeedbacksVarianceFieldsSelection;
        include?: FeedbacksVarianceFieldsSelection;
      };
}

export const includeFeedbacksAggregateFields = <
  T extends FeedbacksAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedbacksAvgFieldsSelection {
  id?: boolean | boolean;
  rating?: boolean | boolean;
}

export const includeFeedbacksAvgFields = <
  T extends FeedbacksAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedbacksMaxFieldsSelection {
  created_at?: boolean | boolean;
  device_info?: boolean | boolean;
  feedback_status?: boolean | boolean;
  feedback_type?: boolean | boolean;
  id?: boolean | boolean;
  message?: boolean | boolean;
  page_identifier?: boolean | boolean;
  rating?: boolean | boolean;
  resolution_comment?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeFeedbacksMaxFields = <
  T extends FeedbacksMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedbacksMinFieldsSelection {
  created_at?: boolean | boolean;
  device_info?: boolean | boolean;
  feedback_status?: boolean | boolean;
  feedback_type?: boolean | boolean;
  id?: boolean | boolean;
  message?: boolean | boolean;
  page_identifier?: boolean | boolean;
  rating?: boolean | boolean;
  resolution_comment?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeFeedbacksMinFields = <
  T extends FeedbacksMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeFeedbacksMutationResponse = <
  T extends FeedbacksMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface FeedbacksStddevFieldsSelection {
  id?: boolean | boolean;
  rating?: boolean | boolean;
}

export const includeFeedbacksStddevFields = <
  T extends FeedbacksStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedbacksStddevPopFieldsSelection {
  id?: boolean | boolean;
  rating?: boolean | boolean;
}

export const includeFeedbacksStddevPopFields = <
  T extends FeedbacksStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedbacksStddevSampFieldsSelection {
  id?: boolean | boolean;
  rating?: boolean | boolean;
}

export const includeFeedbacksStddevSampFields = <
  T extends FeedbacksStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedbacksSumFieldsSelection {
  id?: boolean | boolean;
  rating?: boolean | boolean;
}

export const includeFeedbacksSumFields = <
  T extends FeedbacksSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedbacksVarPopFieldsSelection {
  id?: boolean | boolean;
  rating?: boolean | boolean;
}

export const includeFeedbacksVarPopFields = <
  T extends FeedbacksVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedbacksVarSampFieldsSelection {
  id?: boolean | boolean;
  rating?: boolean | boolean;
}

export const includeFeedbacksVarSampFields = <
  T extends FeedbacksVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedbacksVarianceFieldsSelection {
  id?: boolean | boolean;
  rating?: boolean | boolean;
}

export const includeFeedbacksVarianceFields = <
  T extends FeedbacksVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedsSelection {
  created_at?: boolean | boolean;
  feed_categories?: boolean | boolean;
  feed_categories_aggregate?: boolean | boolean;
  feed_sources?: boolean | boolean;
  feed_sources_aggregate?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  user_id?: boolean | boolean;
  user_profile?:
    | boolean
    | {
        select?: UserProfilesSelection;
        include?: UserProfilesSelection;
      };
}

export const includeFeeds = <T extends FeedsSelection>(include: T) => include;

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

export interface FeedsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: FeedsAggregateFieldsSelection;
        include?: FeedsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeFeedsAggregate = <T extends FeedsAggregateSelection>(
  include: T,
) => include;

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

export interface FeedsAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: FeedsMaxFieldsSelection;
        include?: FeedsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: FeedsMinFieldsSelection;
        include?: FeedsMinFieldsSelection;
      };
}

export const includeFeedsAggregateFields = <
  T extends FeedsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface FeedsMaxFieldsSelection {
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeFeedsMaxFields = <T extends FeedsMaxFieldsSelection>(
  include: T,
) => include;

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

export interface FeedsMinFieldsSelection {
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeFeedsMinFields = <T extends FeedsMinFieldsSelection>(
  include: T,
) => include;

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

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

export const includeFeedsMutationResponse = <
  T extends FeedsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface FollowsSelection {
  created_at?: boolean | boolean;
  followed_entity?: boolean | boolean;
  followed_id?: boolean | boolean;
  id?: boolean | boolean;
  user_id?: boolean | boolean;
  user_profile?: boolean | boolean;
}

export const includeFollows = <T extends FollowsSelection>(include: T) =>
  include;

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

export interface FollowsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: FollowsAggregateFieldsSelection;
        include?: FollowsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeFollowsAggregate = <T extends FollowsAggregateSelection>(
  include: T,
) => include;

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

export interface FollowsAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: FollowsMaxFieldsSelection;
        include?: FollowsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: FollowsMinFieldsSelection;
        include?: FollowsMinFieldsSelection;
      };
}

export const includeFollowsAggregateFields = <
  T extends FollowsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface FollowsMaxFieldsSelection {
  created_at?: boolean | boolean;
  followed_entity?: boolean | boolean;
  followed_id?: boolean | boolean;
  id?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeFollowsMaxFields = <T extends FollowsMaxFieldsSelection>(
  include: T,
) => include;

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

export interface FollowsMinFieldsSelection {
  created_at?: boolean | boolean;
  followed_entity?: boolean | boolean;
  followed_id?: boolean | boolean;
  id?: boolean | boolean;
  user_id?: boolean | boolean;
}

export const includeFollowsMinFields = <T extends FollowsMinFieldsSelection>(
  include: T,
) => include;

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

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

export const includeFollowsMutationResponse = <
  T extends FollowsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface MetricDefinitionsSelection {
  category?: boolean | boolean;
  company_metrics?: boolean | boolean;
  company_metrics_aggregate?: boolean | boolean;
  description?: boolean | boolean;
  id?: boolean | boolean;
  is_dimensional?: boolean | boolean;
  name?: boolean | boolean;
  spider_metrics?: boolean | boolean;
  spider_metrics_aggregate?: boolean | boolean;
  type?: boolean | boolean;
  unit?: boolean | boolean;
}

export const includeMetricDefinitions = <T extends MetricDefinitionsSelection>(
  include: T,
) => include;

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

export interface MetricDefinitionsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: MetricDefinitionsAggregateFieldsSelection;
        include?: MetricDefinitionsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeMetricDefinitionsAggregate = <
  T extends MetricDefinitionsAggregateSelection,
>(
  include: T,
) => include;

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

export interface MetricDefinitionsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: MetricDefinitionsAvgFieldsSelection;
        include?: MetricDefinitionsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: MetricDefinitionsMaxFieldsSelection;
        include?: MetricDefinitionsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: MetricDefinitionsMinFieldsSelection;
        include?: MetricDefinitionsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: MetricDefinitionsStddevFieldsSelection;
        include?: MetricDefinitionsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: MetricDefinitionsStddevPopFieldsSelection;
        include?: MetricDefinitionsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: MetricDefinitionsStddevSampFieldsSelection;
        include?: MetricDefinitionsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: MetricDefinitionsSumFieldsSelection;
        include?: MetricDefinitionsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: MetricDefinitionsVarPopFieldsSelection;
        include?: MetricDefinitionsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: MetricDefinitionsVarSampFieldsSelection;
        include?: MetricDefinitionsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: MetricDefinitionsVarianceFieldsSelection;
        include?: MetricDefinitionsVarianceFieldsSelection;
      };
}

export const includeMetricDefinitionsAggregateFields = <
  T extends MetricDefinitionsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeMetricDefinitionsAvgFields = <
  T extends MetricDefinitionsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface MetricDefinitionsMaxFieldsSelection {
  category?: boolean | boolean;
  description?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  type?: boolean | boolean;
  unit?: boolean | boolean;
}

export const includeMetricDefinitionsMaxFields = <
  T extends MetricDefinitionsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface MetricDefinitionsMinFieldsSelection {
  category?: boolean | boolean;
  description?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  type?: boolean | boolean;
  unit?: boolean | boolean;
}

export const includeMetricDefinitionsMinFields = <
  T extends MetricDefinitionsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeMetricDefinitionsMutationResponse = <
  T extends MetricDefinitionsMutationResponseSelection,
>(
  include: T,
) => include;

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

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

export const includeMetricDefinitionsStddevFields = <
  T extends MetricDefinitionsStddevFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeMetricDefinitionsStddevPopFields = <
  T extends MetricDefinitionsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeMetricDefinitionsStddevSampFields = <
  T extends MetricDefinitionsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeMetricDefinitionsSumFields = <
  T extends MetricDefinitionsSumFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeMetricDefinitionsVarPopFields = <
  T extends MetricDefinitionsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeMetricDefinitionsVarSampFields = <
  T extends MetricDefinitionsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeMetricDefinitionsVarianceFields = <
  T extends MetricDefinitionsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface MutationRootSelection {
  delete_ad_daily_metrics?:
    | boolean
    | {
        select?: AdDailyMetricsMutationResponseSelection;
        include?: AdDailyMetricsMutationResponseSelection;
      };
  delete_ad_daily_metrics_by_pk?:
    | boolean
    | {
        select?: AdDailyMetricsSelection;
        include?: AdDailyMetricsSelection;
      };
  delete_ad_packages?:
    | boolean
    | {
        select?: AdPackagesMutationResponseSelection;
        include?: AdPackagesMutationResponseSelection;
      };
  delete_ad_packages_by_pk?:
    | boolean
    | {
        select?: AdPackagesSelection;
        include?: AdPackagesSelection;
      };
  delete_ad_variants?:
    | boolean
    | {
        select?: AdVariantsMutationResponseSelection;
        include?: AdVariantsMutationResponseSelection;
      };
  delete_ad_variants_by_pk?:
    | boolean
    | {
        select?: AdVariantsSelection;
        include?: AdVariantsSelection;
      };
  delete_addresses?:
    | boolean
    | {
        select?: AddressesMutationResponseSelection;
        include?: AddressesMutationResponseSelection;
      };
  delete_addresses_by_pk?:
    | boolean
    | {
        select?: AddressesSelection;
        include?: AddressesSelection;
      };
  delete_ads?:
    | boolean
    | {
        select?: AdsMutationResponseSelection;
        include?: AdsMutationResponseSelection;
      };
  delete_ads_by_pk?:
    | boolean
    | {
        select?: AdsSelection;
        include?: AdsSelection;
      };
  delete_blacklisted_domains?:
    | boolean
    | {
        select?: BlacklistedDomainsMutationResponseSelection;
        include?: BlacklistedDomainsMutationResponseSelection;
      };
  delete_blacklisted_domains_by_pk?:
    | boolean
    | {
        select?: BlacklistedDomainsSelection;
        include?: BlacklistedDomainsSelection;
      };
  delete_blacklisted_urls?:
    | boolean
    | {
        select?: BlacklistedUrlsMutationResponseSelection;
        include?: BlacklistedUrlsMutationResponseSelection;
      };
  delete_blacklisted_urls_by_pk?:
    | boolean
    | {
        select?: BlacklistedUrlsSelection;
        include?: BlacklistedUrlsSelection;
      };
  delete_blocked_ips?:
    | boolean
    | {
        select?: BlockedIpsMutationResponseSelection;
        include?: BlockedIpsMutationResponseSelection;
      };
  delete_blocked_ips_by_pk?:
    | boolean
    | {
        select?: BlockedIpsSelection;
        include?: BlockedIpsSelection;
      };
  delete_bookmark_folders?:
    | boolean
    | {
        select?: BookmarkFoldersMutationResponseSelection;
        include?: BookmarkFoldersMutationResponseSelection;
      };
  delete_bookmark_folders_by_pk?:
    | boolean
    | {
        select?: BookmarkFoldersSelection;
        include?: BookmarkFoldersSelection;
      };
  delete_bookmarks?:
    | boolean
    | {
        select?: BookmarksMutationResponseSelection;
        include?: BookmarksMutationResponseSelection;
      };
  delete_bookmarks_by_pk?:
    | boolean
    | {
        select?: BookmarksSelection;
        include?: BookmarksSelection;
      };
  delete_business_domains?:
    | boolean
    | {
        select?: BusinessDomainsMutationResponseSelection;
        include?: BusinessDomainsMutationResponseSelection;
      };
  delete_business_domains_by_pk?:
    | boolean
    | {
        select?: BusinessDomainsSelection;
        include?: BusinessDomainsSelection;
      };
  delete_categories?:
    | boolean
    | {
        select?: CategoriesMutationResponseSelection;
        include?: CategoriesMutationResponseSelection;
      };
  delete_categories_by_pk?:
    | boolean
    | {
        select?: CategoriesSelection;
        include?: CategoriesSelection;
      };
  delete_categorized_urls?:
    | boolean
    | {
        select?: CategorizedUrlsMutationResponseSelection;
        include?: CategorizedUrlsMutationResponseSelection;
      };
  delete_categorized_urls_by_pk?:
    | boolean
    | {
        select?: CategorizedUrlsSelection;
        include?: CategorizedUrlsSelection;
      };
  delete_circuit_breaker_states?:
    | boolean
    | {
        select?: CircuitBreakerStatesMutationResponseSelection;
        include?: CircuitBreakerStatesMutationResponseSelection;
      };
  delete_circuit_breaker_states_by_pk?:
    | boolean
    | {
        select?: CircuitBreakerStatesSelection;
        include?: CircuitBreakerStatesSelection;
      };
  delete_cities?:
    | boolean
    | {
        select?: CitiesMutationResponseSelection;
        include?: CitiesMutationResponseSelection;
      };
  delete_cities_by_pk?:
    | boolean
    | {
        select?: CitiesSelection;
        include?: CitiesSelection;
      };
  delete_comments?:
    | boolean
    | {
        select?: CommentsMutationResponseSelection;
        include?: CommentsMutationResponseSelection;
      };
  delete_comments_by_pk?:
    | boolean
    | {
        select?: CommentsSelection;
        include?: CommentsSelection;
      };
  delete_companies?:
    | boolean
    | {
        select?: CompaniesMutationResponseSelection;
        include?: CompaniesMutationResponseSelection;
      };
  delete_companies_by_pk?:
    | boolean
    | {
        select?: CompaniesSelection;
        include?: CompaniesSelection;
      };
  delete_company_contacts?:
    | boolean
    | {
        select?: CompanyContactsMutationResponseSelection;
        include?: CompanyContactsMutationResponseSelection;
      };
  delete_company_contacts_by_pk?:
    | boolean
    | {
        select?: CompanyContactsSelection;
        include?: CompanyContactsSelection;
      };
  delete_company_employees?:
    | boolean
    | {
        select?: CompanyEmployeesMutationResponseSelection;
        include?: CompanyEmployeesMutationResponseSelection;
      };
  delete_company_employees_by_pk?:
    | boolean
    | {
        select?: CompanyEmployeesSelection;
        include?: CompanyEmployeesSelection;
      };
  delete_company_extras?:
    | boolean
    | {
        select?: CompanyExtrasMutationResponseSelection;
        include?: CompanyExtrasMutationResponseSelection;
      };
  delete_company_extras_by_pk?:
    | boolean
    | {
        select?: CompanyExtrasSelection;
        include?: CompanyExtrasSelection;
      };
  delete_company_metrics?:
    | boolean
    | {
        select?: CompanyMetricsMutationResponseSelection;
        include?: CompanyMetricsMutationResponseSelection;
      };
  delete_company_metrics_by_pk?:
    | boolean
    | {
        select?: CompanyMetricsSelection;
        include?: CompanyMetricsSelection;
      };
  delete_contacts?:
    | boolean
    | {
        select?: ContactsMutationResponseSelection;
        include?: ContactsMutationResponseSelection;
      };
  delete_contacts_by_pk?:
    | boolean
    | {
        select?: ContactsSelection;
        include?: ContactsSelection;
      };
  delete_content_categories?:
    | boolean
    | {
        select?: ContentCategoriesMutationResponseSelection;
        include?: ContentCategoriesMutationResponseSelection;
      };
  delete_content_categories_by_pk?:
    | boolean
    | {
        select?: ContentCategoriesSelection;
        include?: ContentCategoriesSelection;
      };
  delete_content_source_visits?:
    | boolean
    | {
        select?: ContentSourceVisitsMutationResponseSelection;
        include?: ContentSourceVisitsMutationResponseSelection;
      };
  delete_content_source_visits_by_pk?:
    | boolean
    | {
        select?: ContentSourceVisitsSelection;
        include?: ContentSourceVisitsSelection;
      };
  delete_content_sources?:
    | boolean
    | {
        select?: ContentSourcesMutationResponseSelection;
        include?: ContentSourcesMutationResponseSelection;
      };
  delete_content_sources_by_pk?:
    | boolean
    | {
        select?: ContentSourcesSelection;
        include?: ContentSourcesSelection;
      };
  delete_content_statuses?:
    | boolean
    | {
        select?: ContentStatusesMutationResponseSelection;
        include?: ContentStatusesMutationResponseSelection;
      };
  delete_content_statuses_by_pk?:
    | boolean
    | {
        select?: ContentStatusesSelection;
        include?: ContentStatusesSelection;
      };
  delete_content_tags?:
    | boolean
    | {
        select?: ContentTagsMutationResponseSelection;
        include?: ContentTagsMutationResponseSelection;
      };
  delete_content_tags_by_pk?:
    | boolean
    | {
        select?: ContentTagsSelection;
        include?: ContentTagsSelection;
      };
  delete_contents?:
    | boolean
    | {
        select?: ContentsMutationResponseSelection;
        include?: ContentsMutationResponseSelection;
      };
  delete_contents_by_pk?:
    | boolean
    | {
        select?: ContentsSelection;
        include?: ContentsSelection;
      };
  delete_countries?:
    | boolean
    | {
        select?: CountriesMutationResponseSelection;
        include?: CountriesMutationResponseSelection;
      };
  delete_countries_by_pk?:
    | boolean
    | {
        select?: CountriesSelection;
        include?: CountriesSelection;
      };
  delete_customer_payments?:
    | boolean
    | {
        select?: CustomerPaymentsMutationResponseSelection;
        include?: CustomerPaymentsMutationResponseSelection;
      };
  delete_customer_payments_by_pk?:
    | boolean
    | {
        select?: CustomerPaymentsSelection;
        include?: CustomerPaymentsSelection;
      };
  delete_customer_processed_webhooks?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksMutationResponseSelection;
        include?: CustomerProcessedWebhooksMutationResponseSelection;
      };
  delete_customer_processed_webhooks_by_pk?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksSelection;
        include?: CustomerProcessedWebhooksSelection;
      };
  delete_customer_refunds?:
    | boolean
    | {
        select?: CustomerRefundsMutationResponseSelection;
        include?: CustomerRefundsMutationResponseSelection;
      };
  delete_customer_refunds_by_pk?:
    | boolean
    | {
        select?: CustomerRefundsSelection;
        include?: CustomerRefundsSelection;
      };
  delete_customer_subscription_plans?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansMutationResponseSelection;
        include?: CustomerSubscriptionPlansMutationResponseSelection;
      };
  delete_customer_subscription_plans_by_pk?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansSelection;
        include?: CustomerSubscriptionPlansSelection;
      };
  delete_customer_subscriptions?:
    | boolean
    | {
        select?: CustomerSubscriptionsMutationResponseSelection;
        include?: CustomerSubscriptionsMutationResponseSelection;
      };
  delete_customer_subscriptions_by_pk?:
    | boolean
    | {
        select?: CustomerSubscriptionsSelection;
        include?: CustomerSubscriptionsSelection;
      };
  delete_embedding_reviews?:
    | boolean
    | {
        select?: EmbeddingReviewsMutationResponseSelection;
        include?: EmbeddingReviewsMutationResponseSelection;
      };
  delete_embedding_reviews_by_pk?:
    | boolean
    | {
        select?: EmbeddingReviewsSelection;
        include?: EmbeddingReviewsSelection;
      };
  delete_error_logs?:
    | boolean
    | {
        select?: ErrorLogsMutationResponseSelection;
        include?: ErrorLogsMutationResponseSelection;
      };
  delete_error_logs_by_pk?:
    | boolean
    | {
        select?: ErrorLogsSelection;
        include?: ErrorLogsSelection;
      };
  delete_feature_requests?:
    | boolean
    | {
        select?: FeatureRequestsMutationResponseSelection;
        include?: FeatureRequestsMutationResponseSelection;
      };
  delete_feature_requests_by_pk?:
    | boolean
    | {
        select?: FeatureRequestsSelection;
        include?: FeatureRequestsSelection;
      };
  delete_feature_votes?:
    | boolean
    | {
        select?: FeatureVotesMutationResponseSelection;
        include?: FeatureVotesMutationResponseSelection;
      };
  delete_feature_votes_by_pk?:
    | boolean
    | {
        select?: FeatureVotesSelection;
        include?: FeatureVotesSelection;
      };
  delete_feed_categories?:
    | boolean
    | {
        select?: FeedCategoriesMutationResponseSelection;
        include?: FeedCategoriesMutationResponseSelection;
      };
  delete_feed_categories_by_pk?:
    | boolean
    | {
        select?: FeedCategoriesSelection;
        include?: FeedCategoriesSelection;
      };
  delete_feed_sources?:
    | boolean
    | {
        select?: FeedSourcesMutationResponseSelection;
        include?: FeedSourcesMutationResponseSelection;
      };
  delete_feed_sources_by_pk?:
    | boolean
    | {
        select?: FeedSourcesSelection;
        include?: FeedSourcesSelection;
      };
  delete_feedbacks?:
    | boolean
    | {
        select?: FeedbacksMutationResponseSelection;
        include?: FeedbacksMutationResponseSelection;
      };
  delete_feedbacks_by_pk?:
    | boolean
    | {
        select?: FeedbacksSelection;
        include?: FeedbacksSelection;
      };
  delete_feeds?:
    | boolean
    | {
        select?: FeedsMutationResponseSelection;
        include?: FeedsMutationResponseSelection;
      };
  delete_feeds_by_pk?:
    | boolean
    | {
        select?: FeedsSelection;
        include?: FeedsSelection;
      };
  delete_follows?:
    | boolean
    | {
        select?: FollowsMutationResponseSelection;
        include?: FollowsMutationResponseSelection;
      };
  delete_follows_by_pk?:
    | boolean
    | {
        select?: FollowsSelection;
        include?: FollowsSelection;
      };
  delete_metric_definitions?:
    | boolean
    | {
        select?: MetricDefinitionsMutationResponseSelection;
        include?: MetricDefinitionsMutationResponseSelection;
      };
  delete_metric_definitions_by_pk?:
    | boolean
    | {
        select?: MetricDefinitionsSelection;
        include?: MetricDefinitionsSelection;
      };
  delete_news?:
    | boolean
    | {
        select?: NewsMutationResponseSelection;
        include?: NewsMutationResponseSelection;
      };
  delete_news_by_pk?:
    | boolean
    | {
        select?: NewsSelection;
        include?: NewsSelection;
      };
  delete_news_summaries?:
    | boolean
    | {
        select?: NewsSummariesMutationResponseSelection;
        include?: NewsSummariesMutationResponseSelection;
      };
  delete_news_summaries_by_pk?:
    | boolean
    | {
        select?: NewsSummariesSelection;
        include?: NewsSummariesSelection;
      };
  delete_news_tags?:
    | boolean
    | {
        select?: NewsTagsMutationResponseSelection;
        include?: NewsTagsMutationResponseSelection;
      };
  delete_news_tags_by_pk?:
    | boolean
    | {
        select?: NewsTagsSelection;
        include?: NewsTagsSelection;
      };
  delete_newsletters?:
    | boolean
    | {
        select?: NewslettersMutationResponseSelection;
        include?: NewslettersMutationResponseSelection;
      };
  delete_newsletters_by_pk?:
    | boolean
    | {
        select?: NewslettersSelection;
        include?: NewslettersSelection;
      };
  delete_payment_providers?:
    | boolean
    | {
        select?: PaymentProvidersMutationResponseSelection;
        include?: PaymentProvidersMutationResponseSelection;
      };
  delete_payment_providers_by_pk?:
    | boolean
    | {
        select?: PaymentProvidersSelection;
        include?: PaymentProvidersSelection;
      };
  delete_plan_permissions?:
    | boolean
    | {
        select?: PlanPermissionsMutationResponseSelection;
        include?: PlanPermissionsMutationResponseSelection;
      };
  delete_plan_permissions_by_pk?:
    | boolean
    | {
        select?: PlanPermissionsSelection;
        include?: PlanPermissionsSelection;
      };
  delete_recent_errors?:
    | boolean
    | {
        select?: RecentErrorsMutationResponseSelection;
        include?: RecentErrorsMutationResponseSelection;
      };
  delete_referrals?:
    | boolean
    | {
        select?: ReferralsMutationResponseSelection;
        include?: ReferralsMutationResponseSelection;
      };
  delete_referrals_by_pk?:
    | boolean
    | {
        select?: ReferralsSelection;
        include?: ReferralsSelection;
      };
  delete_referrer_blocks?:
    | boolean
    | {
        select?: ReferrerBlocksMutationResponseSelection;
        include?: ReferrerBlocksMutationResponseSelection;
      };
  delete_referrer_blocks_by_pk?:
    | boolean
    | {
        select?: ReferrerBlocksSelection;
        include?: ReferrerBlocksSelection;
      };
  delete_research?:
    | boolean
    | {
        select?: ResearchMutationResponseSelection;
        include?: ResearchMutationResponseSelection;
      };
  delete_research_by_pk?:
    | boolean
    | {
        select?: ResearchSelection;
        include?: ResearchSelection;
      };
  delete_research_embeddings?:
    | boolean
    | {
        select?: ResearchEmbeddingsMutationResponseSelection;
        include?: ResearchEmbeddingsMutationResponseSelection;
      };
  delete_research_embeddings_by_pk?:
    | boolean
    | {
        select?: ResearchEmbeddingsSelection;
        include?: ResearchEmbeddingsSelection;
      };
  delete_responses?:
    | boolean
    | {
        select?: ResponsesMutationResponseSelection;
        include?: ResponsesMutationResponseSelection;
      };
  delete_responses_by_pk?:
    | boolean
    | {
        select?: ResponsesSelection;
        include?: ResponsesSelection;
      };
  delete_role_hierarchy?:
    | boolean
    | {
        select?: RoleHierarchyMutationResponseSelection;
        include?: RoleHierarchyMutationResponseSelection;
      };
  delete_role_hierarchy_by_pk?:
    | boolean
    | {
        select?: RoleHierarchySelection;
        include?: RoleHierarchySelection;
      };
  delete_role_permissions?:
    | boolean
    | {
        select?: RolePermissionsMutationResponseSelection;
        include?: RolePermissionsMutationResponseSelection;
      };
  delete_role_permissions_by_pk?:
    | boolean
    | {
        select?: RolePermissionsSelection;
        include?: RolePermissionsSelection;
      };
  delete_role_permissions_materialized?:
    | boolean
    | {
        select?: RolePermissionsMaterializedMutationResponseSelection;
        include?: RolePermissionsMaterializedMutationResponseSelection;
      };
  delete_role_permissions_materialized_by_pk?:
    | boolean
    | {
        select?: RolePermissionsMaterializedSelection;
        include?: RolePermissionsMaterializedSelection;
      };
  delete_scoring_weights?:
    | boolean
    | {
        select?: ScoringWeightsMutationResponseSelection;
        include?: ScoringWeightsMutationResponseSelection;
      };
  delete_scoring_weights_by_pk?:
    | boolean
    | {
        select?: ScoringWeightsSelection;
        include?: ScoringWeightsSelection;
      };
  delete_searches?:
    | boolean
    | {
        select?: SearchesMutationResponseSelection;
        include?: SearchesMutationResponseSelection;
      };
  delete_searches_by_pk?:
    | boolean
    | {
        select?: SearchesSelection;
        include?: SearchesSelection;
      };
  delete_social_media?:
    | boolean
    | {
        select?: SocialMediaMutationResponseSelection;
        include?: SocialMediaMutationResponseSelection;
      };
  delete_social_media_by_pk?:
    | boolean
    | {
        select?: SocialMediaSelection;
        include?: SocialMediaSelection;
      };
  delete_spider_metrics?:
    | boolean
    | {
        select?: SpiderMetricsMutationResponseSelection;
        include?: SpiderMetricsMutationResponseSelection;
      };
  delete_spider_metrics_by_pk?:
    | boolean
    | {
        select?: SpiderMetricsSelection;
        include?: SpiderMetricsSelection;
      };
  delete_strapi_migrations?:
    | boolean
    | {
        select?: StrapiMigrationsMutationResponseSelection;
        include?: StrapiMigrationsMutationResponseSelection;
      };
  delete_strapi_migrations_by_pk?:
    | boolean
    | {
        select?: StrapiMigrationsSelection;
        include?: StrapiMigrationsSelection;
      };
  delete_strapi_migrations_internal?:
    | boolean
    | {
        select?: StrapiMigrationsInternalMutationResponseSelection;
        include?: StrapiMigrationsInternalMutationResponseSelection;
      };
  delete_strapi_migrations_internal_by_pk?:
    | boolean
    | {
        select?: StrapiMigrationsInternalSelection;
        include?: StrapiMigrationsInternalSelection;
      };
  delete_table_maintenance_log?:
    | boolean
    | {
        select?: TableMaintenanceLogMutationResponseSelection;
        include?: TableMaintenanceLogMutationResponseSelection;
      };
  delete_table_maintenance_log_by_pk?:
    | boolean
    | {
        select?: TableMaintenanceLogSelection;
        include?: TableMaintenanceLogSelection;
      };
  delete_table_query_performance?:
    | boolean
    | {
        select?: TableQueryPerformanceMutationResponseSelection;
        include?: TableQueryPerformanceMutationResponseSelection;
      };
  delete_table_sequence_usage?:
    | boolean
    | {
        select?: TableSequenceUsageMutationResponseSelection;
        include?: TableSequenceUsageMutationResponseSelection;
      };
  delete_table_statistics?:
    | boolean
    | {
        select?: TableStatisticsMutationResponseSelection;
        include?: TableStatisticsMutationResponseSelection;
      };
  delete_table_statistics_by_pk?:
    | boolean
    | {
        select?: TableStatisticsSelection;
        include?: TableStatisticsSelection;
      };
  delete_tags?:
    | boolean
    | {
        select?: TagsMutationResponseSelection;
        include?: TagsMutationResponseSelection;
      };
  delete_tags_by_pk?:
    | boolean
    | {
        select?: TagsSelection;
        include?: TagsSelection;
      };
  delete_user_metrics?:
    | boolean
    | {
        select?: UserMetricsMutationResponseSelection;
        include?: UserMetricsMutationResponseSelection;
      };
  delete_user_metrics_by_pk?:
    | boolean
    | {
        select?: UserMetricsSelection;
        include?: UserMetricsSelection;
      };
  delete_user_profiles?:
    | boolean
    | {
        select?: UserProfilesMutationResponseSelection;
        include?: UserProfilesMutationResponseSelection;
      };
  delete_user_profiles_by_pk?:
    | boolean
    | {
        select?: UserProfilesSelection;
        include?: UserProfilesSelection;
      };
  delete_votes?:
    | boolean
    | {
        select?: VotesMutationResponseSelection;
        include?: VotesMutationResponseSelection;
      };
  delete_votes_by_pk?:
    | boolean
    | {
        select?: VotesSelection;
        include?: VotesSelection;
      };
  delete_workflows?:
    | boolean
    | {
        select?: WorkflowsMutationResponseSelection;
        include?: WorkflowsMutationResponseSelection;
      };
  delete_workflows_by_pk?:
    | boolean
    | {
        select?: WorkflowsSelection;
        include?: WorkflowsSelection;
      };
  insert_ad_daily_metrics?:
    | boolean
    | {
        select?: AdDailyMetricsMutationResponseSelection;
        include?: AdDailyMetricsMutationResponseSelection;
      };
  insert_ad_daily_metrics_one?:
    | boolean
    | {
        select?: AdDailyMetricsSelection;
        include?: AdDailyMetricsSelection;
      };
  insert_ad_packages?:
    | boolean
    | {
        select?: AdPackagesMutationResponseSelection;
        include?: AdPackagesMutationResponseSelection;
      };
  insert_ad_packages_one?:
    | boolean
    | {
        select?: AdPackagesSelection;
        include?: AdPackagesSelection;
      };
  insert_ad_variants?:
    | boolean
    | {
        select?: AdVariantsMutationResponseSelection;
        include?: AdVariantsMutationResponseSelection;
      };
  insert_ad_variants_one?:
    | boolean
    | {
        select?: AdVariantsSelection;
        include?: AdVariantsSelection;
      };
  insert_addresses?:
    | boolean
    | {
        select?: AddressesMutationResponseSelection;
        include?: AddressesMutationResponseSelection;
      };
  insert_addresses_one?:
    | boolean
    | {
        select?: AddressesSelection;
        include?: AddressesSelection;
      };
  insert_ads?:
    | boolean
    | {
        select?: AdsMutationResponseSelection;
        include?: AdsMutationResponseSelection;
      };
  insert_ads_one?:
    | boolean
    | {
        select?: AdsSelection;
        include?: AdsSelection;
      };
  insert_blacklisted_domains?:
    | boolean
    | {
        select?: BlacklistedDomainsMutationResponseSelection;
        include?: BlacklistedDomainsMutationResponseSelection;
      };
  insert_blacklisted_domains_one?:
    | boolean
    | {
        select?: BlacklistedDomainsSelection;
        include?: BlacklistedDomainsSelection;
      };
  insert_blacklisted_urls?:
    | boolean
    | {
        select?: BlacklistedUrlsMutationResponseSelection;
        include?: BlacklistedUrlsMutationResponseSelection;
      };
  insert_blacklisted_urls_one?:
    | boolean
    | {
        select?: BlacklistedUrlsSelection;
        include?: BlacklistedUrlsSelection;
      };
  insert_blocked_ips?:
    | boolean
    | {
        select?: BlockedIpsMutationResponseSelection;
        include?: BlockedIpsMutationResponseSelection;
      };
  insert_blocked_ips_one?:
    | boolean
    | {
        select?: BlockedIpsSelection;
        include?: BlockedIpsSelection;
      };
  insert_bookmark_folders?:
    | boolean
    | {
        select?: BookmarkFoldersMutationResponseSelection;
        include?: BookmarkFoldersMutationResponseSelection;
      };
  insert_bookmark_folders_one?:
    | boolean
    | {
        select?: BookmarkFoldersSelection;
        include?: BookmarkFoldersSelection;
      };
  insert_bookmarks?:
    | boolean
    | {
        select?: BookmarksMutationResponseSelection;
        include?: BookmarksMutationResponseSelection;
      };
  insert_bookmarks_one?:
    | boolean
    | {
        select?: BookmarksSelection;
        include?: BookmarksSelection;
      };
  insert_business_domains?:
    | boolean
    | {
        select?: BusinessDomainsMutationResponseSelection;
        include?: BusinessDomainsMutationResponseSelection;
      };
  insert_business_domains_one?:
    | boolean
    | {
        select?: BusinessDomainsSelection;
        include?: BusinessDomainsSelection;
      };
  insert_categories?:
    | boolean
    | {
        select?: CategoriesMutationResponseSelection;
        include?: CategoriesMutationResponseSelection;
      };
  insert_categories_one?:
    | boolean
    | {
        select?: CategoriesSelection;
        include?: CategoriesSelection;
      };
  insert_categorized_urls?:
    | boolean
    | {
        select?: CategorizedUrlsMutationResponseSelection;
        include?: CategorizedUrlsMutationResponseSelection;
      };
  insert_categorized_urls_one?:
    | boolean
    | {
        select?: CategorizedUrlsSelection;
        include?: CategorizedUrlsSelection;
      };
  insert_circuit_breaker_states?:
    | boolean
    | {
        select?: CircuitBreakerStatesMutationResponseSelection;
        include?: CircuitBreakerStatesMutationResponseSelection;
      };
  insert_circuit_breaker_states_one?:
    | boolean
    | {
        select?: CircuitBreakerStatesSelection;
        include?: CircuitBreakerStatesSelection;
      };
  insert_cities?:
    | boolean
    | {
        select?: CitiesMutationResponseSelection;
        include?: CitiesMutationResponseSelection;
      };
  insert_cities_one?:
    | boolean
    | {
        select?: CitiesSelection;
        include?: CitiesSelection;
      };
  insert_comments?:
    | boolean
    | {
        select?: CommentsMutationResponseSelection;
        include?: CommentsMutationResponseSelection;
      };
  insert_comments_one?:
    | boolean
    | {
        select?: CommentsSelection;
        include?: CommentsSelection;
      };
  insert_companies?:
    | boolean
    | {
        select?: CompaniesMutationResponseSelection;
        include?: CompaniesMutationResponseSelection;
      };
  insert_companies_one?:
    | boolean
    | {
        select?: CompaniesSelection;
        include?: CompaniesSelection;
      };
  insert_company_contacts?:
    | boolean
    | {
        select?: CompanyContactsMutationResponseSelection;
        include?: CompanyContactsMutationResponseSelection;
      };
  insert_company_contacts_one?:
    | boolean
    | {
        select?: CompanyContactsSelection;
        include?: CompanyContactsSelection;
      };
  insert_company_employees?:
    | boolean
    | {
        select?: CompanyEmployeesMutationResponseSelection;
        include?: CompanyEmployeesMutationResponseSelection;
      };
  insert_company_employees_one?:
    | boolean
    | {
        select?: CompanyEmployeesSelection;
        include?: CompanyEmployeesSelection;
      };
  insert_company_extras?:
    | boolean
    | {
        select?: CompanyExtrasMutationResponseSelection;
        include?: CompanyExtrasMutationResponseSelection;
      };
  insert_company_extras_one?:
    | boolean
    | {
        select?: CompanyExtrasSelection;
        include?: CompanyExtrasSelection;
      };
  insert_company_metrics?:
    | boolean
    | {
        select?: CompanyMetricsMutationResponseSelection;
        include?: CompanyMetricsMutationResponseSelection;
      };
  insert_company_metrics_one?:
    | boolean
    | {
        select?: CompanyMetricsSelection;
        include?: CompanyMetricsSelection;
      };
  insert_contacts?:
    | boolean
    | {
        select?: ContactsMutationResponseSelection;
        include?: ContactsMutationResponseSelection;
      };
  insert_contacts_one?:
    | boolean
    | {
        select?: ContactsSelection;
        include?: ContactsSelection;
      };
  insert_content_categories?:
    | boolean
    | {
        select?: ContentCategoriesMutationResponseSelection;
        include?: ContentCategoriesMutationResponseSelection;
      };
  insert_content_categories_one?:
    | boolean
    | {
        select?: ContentCategoriesSelection;
        include?: ContentCategoriesSelection;
      };
  insert_content_source_visits?:
    | boolean
    | {
        select?: ContentSourceVisitsMutationResponseSelection;
        include?: ContentSourceVisitsMutationResponseSelection;
      };
  insert_content_source_visits_one?:
    | boolean
    | {
        select?: ContentSourceVisitsSelection;
        include?: ContentSourceVisitsSelection;
      };
  insert_content_sources?:
    | boolean
    | {
        select?: ContentSourcesMutationResponseSelection;
        include?: ContentSourcesMutationResponseSelection;
      };
  insert_content_sources_one?:
    | boolean
    | {
        select?: ContentSourcesSelection;
        include?: ContentSourcesSelection;
      };
  insert_content_statuses?:
    | boolean
    | {
        select?: ContentStatusesMutationResponseSelection;
        include?: ContentStatusesMutationResponseSelection;
      };
  insert_content_statuses_one?:
    | boolean
    | {
        select?: ContentStatusesSelection;
        include?: ContentStatusesSelection;
      };
  insert_content_tags?:
    | boolean
    | {
        select?: ContentTagsMutationResponseSelection;
        include?: ContentTagsMutationResponseSelection;
      };
  insert_content_tags_one?:
    | boolean
    | {
        select?: ContentTagsSelection;
        include?: ContentTagsSelection;
      };
  insert_contents?:
    | boolean
    | {
        select?: ContentsMutationResponseSelection;
        include?: ContentsMutationResponseSelection;
      };
  insert_contents_one?:
    | boolean
    | {
        select?: ContentsSelection;
        include?: ContentsSelection;
      };
  insert_countries?:
    | boolean
    | {
        select?: CountriesMutationResponseSelection;
        include?: CountriesMutationResponseSelection;
      };
  insert_countries_one?:
    | boolean
    | {
        select?: CountriesSelection;
        include?: CountriesSelection;
      };
  insert_customer_payments?:
    | boolean
    | {
        select?: CustomerPaymentsMutationResponseSelection;
        include?: CustomerPaymentsMutationResponseSelection;
      };
  insert_customer_payments_one?:
    | boolean
    | {
        select?: CustomerPaymentsSelection;
        include?: CustomerPaymentsSelection;
      };
  insert_customer_processed_webhooks?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksMutationResponseSelection;
        include?: CustomerProcessedWebhooksMutationResponseSelection;
      };
  insert_customer_processed_webhooks_one?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksSelection;
        include?: CustomerProcessedWebhooksSelection;
      };
  insert_customer_refunds?:
    | boolean
    | {
        select?: CustomerRefundsMutationResponseSelection;
        include?: CustomerRefundsMutationResponseSelection;
      };
  insert_customer_refunds_one?:
    | boolean
    | {
        select?: CustomerRefundsSelection;
        include?: CustomerRefundsSelection;
      };
  insert_customer_subscription_plans?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansMutationResponseSelection;
        include?: CustomerSubscriptionPlansMutationResponseSelection;
      };
  insert_customer_subscription_plans_one?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansSelection;
        include?: CustomerSubscriptionPlansSelection;
      };
  insert_customer_subscriptions?:
    | boolean
    | {
        select?: CustomerSubscriptionsMutationResponseSelection;
        include?: CustomerSubscriptionsMutationResponseSelection;
      };
  insert_customer_subscriptions_one?:
    | boolean
    | {
        select?: CustomerSubscriptionsSelection;
        include?: CustomerSubscriptionsSelection;
      };
  insert_embedding_reviews?:
    | boolean
    | {
        select?: EmbeddingReviewsMutationResponseSelection;
        include?: EmbeddingReviewsMutationResponseSelection;
      };
  insert_embedding_reviews_one?:
    | boolean
    | {
        select?: EmbeddingReviewsSelection;
        include?: EmbeddingReviewsSelection;
      };
  insert_error_logs?:
    | boolean
    | {
        select?: ErrorLogsMutationResponseSelection;
        include?: ErrorLogsMutationResponseSelection;
      };
  insert_error_logs_one?:
    | boolean
    | {
        select?: ErrorLogsSelection;
        include?: ErrorLogsSelection;
      };
  insert_feature_requests?:
    | boolean
    | {
        select?: FeatureRequestsMutationResponseSelection;
        include?: FeatureRequestsMutationResponseSelection;
      };
  insert_feature_requests_one?:
    | boolean
    | {
        select?: FeatureRequestsSelection;
        include?: FeatureRequestsSelection;
      };
  insert_feature_votes?:
    | boolean
    | {
        select?: FeatureVotesMutationResponseSelection;
        include?: FeatureVotesMutationResponseSelection;
      };
  insert_feature_votes_one?:
    | boolean
    | {
        select?: FeatureVotesSelection;
        include?: FeatureVotesSelection;
      };
  insert_feed_categories?:
    | boolean
    | {
        select?: FeedCategoriesMutationResponseSelection;
        include?: FeedCategoriesMutationResponseSelection;
      };
  insert_feed_categories_one?:
    | boolean
    | {
        select?: FeedCategoriesSelection;
        include?: FeedCategoriesSelection;
      };
  insert_feed_sources?:
    | boolean
    | {
        select?: FeedSourcesMutationResponseSelection;
        include?: FeedSourcesMutationResponseSelection;
      };
  insert_feed_sources_one?:
    | boolean
    | {
        select?: FeedSourcesSelection;
        include?: FeedSourcesSelection;
      };
  insert_feedbacks?:
    | boolean
    | {
        select?: FeedbacksMutationResponseSelection;
        include?: FeedbacksMutationResponseSelection;
      };
  insert_feedbacks_one?:
    | boolean
    | {
        select?: FeedbacksSelection;
        include?: FeedbacksSelection;
      };
  insert_feeds?:
    | boolean
    | {
        select?: FeedsMutationResponseSelection;
        include?: FeedsMutationResponseSelection;
      };
  insert_feeds_one?:
    | boolean
    | {
        select?: FeedsSelection;
        include?: FeedsSelection;
      };
  insert_follows?:
    | boolean
    | {
        select?: FollowsMutationResponseSelection;
        include?: FollowsMutationResponseSelection;
      };
  insert_follows_one?:
    | boolean
    | {
        select?: FollowsSelection;
        include?: FollowsSelection;
      };
  insert_metric_definitions?:
    | boolean
    | {
        select?: MetricDefinitionsMutationResponseSelection;
        include?: MetricDefinitionsMutationResponseSelection;
      };
  insert_metric_definitions_one?:
    | boolean
    | {
        select?: MetricDefinitionsSelection;
        include?: MetricDefinitionsSelection;
      };
  insert_news?:
    | boolean
    | {
        select?: NewsMutationResponseSelection;
        include?: NewsMutationResponseSelection;
      };
  insert_news_one?:
    | boolean
    | {
        select?: NewsSelection;
        include?: NewsSelection;
      };
  insert_news_summaries?:
    | boolean
    | {
        select?: NewsSummariesMutationResponseSelection;
        include?: NewsSummariesMutationResponseSelection;
      };
  insert_news_summaries_one?:
    | boolean
    | {
        select?: NewsSummariesSelection;
        include?: NewsSummariesSelection;
      };
  insert_news_tags?:
    | boolean
    | {
        select?: NewsTagsMutationResponseSelection;
        include?: NewsTagsMutationResponseSelection;
      };
  insert_news_tags_one?:
    | boolean
    | {
        select?: NewsTagsSelection;
        include?: NewsTagsSelection;
      };
  insert_newsletters?:
    | boolean
    | {
        select?: NewslettersMutationResponseSelection;
        include?: NewslettersMutationResponseSelection;
      };
  insert_newsletters_one?:
    | boolean
    | {
        select?: NewslettersSelection;
        include?: NewslettersSelection;
      };
  insert_payment_providers?:
    | boolean
    | {
        select?: PaymentProvidersMutationResponseSelection;
        include?: PaymentProvidersMutationResponseSelection;
      };
  insert_payment_providers_one?:
    | boolean
    | {
        select?: PaymentProvidersSelection;
        include?: PaymentProvidersSelection;
      };
  insert_plan_permissions?:
    | boolean
    | {
        select?: PlanPermissionsMutationResponseSelection;
        include?: PlanPermissionsMutationResponseSelection;
      };
  insert_plan_permissions_one?:
    | boolean
    | {
        select?: PlanPermissionsSelection;
        include?: PlanPermissionsSelection;
      };
  insert_recent_errors?:
    | boolean
    | {
        select?: RecentErrorsMutationResponseSelection;
        include?: RecentErrorsMutationResponseSelection;
      };
  insert_recent_errors_one?:
    | boolean
    | {
        select?: RecentErrorsSelection;
        include?: RecentErrorsSelection;
      };
  insert_referrals?:
    | boolean
    | {
        select?: ReferralsMutationResponseSelection;
        include?: ReferralsMutationResponseSelection;
      };
  insert_referrals_one?:
    | boolean
    | {
        select?: ReferralsSelection;
        include?: ReferralsSelection;
      };
  insert_referrer_blocks?:
    | boolean
    | {
        select?: ReferrerBlocksMutationResponseSelection;
        include?: ReferrerBlocksMutationResponseSelection;
      };
  insert_referrer_blocks_one?:
    | boolean
    | {
        select?: ReferrerBlocksSelection;
        include?: ReferrerBlocksSelection;
      };
  insert_research?:
    | boolean
    | {
        select?: ResearchMutationResponseSelection;
        include?: ResearchMutationResponseSelection;
      };
  insert_research_embeddings?:
    | boolean
    | {
        select?: ResearchEmbeddingsMutationResponseSelection;
        include?: ResearchEmbeddingsMutationResponseSelection;
      };
  insert_research_embeddings_one?:
    | boolean
    | {
        select?: ResearchEmbeddingsSelection;
        include?: ResearchEmbeddingsSelection;
      };
  insert_research_one?:
    | boolean
    | {
        select?: ResearchSelection;
        include?: ResearchSelection;
      };
  insert_responses?:
    | boolean
    | {
        select?: ResponsesMutationResponseSelection;
        include?: ResponsesMutationResponseSelection;
      };
  insert_responses_one?:
    | boolean
    | {
        select?: ResponsesSelection;
        include?: ResponsesSelection;
      };
  insert_role_hierarchy?:
    | boolean
    | {
        select?: RoleHierarchyMutationResponseSelection;
        include?: RoleHierarchyMutationResponseSelection;
      };
  insert_role_hierarchy_one?:
    | boolean
    | {
        select?: RoleHierarchySelection;
        include?: RoleHierarchySelection;
      };
  insert_role_permissions?:
    | boolean
    | {
        select?: RolePermissionsMutationResponseSelection;
        include?: RolePermissionsMutationResponseSelection;
      };
  insert_role_permissions_materialized?:
    | boolean
    | {
        select?: RolePermissionsMaterializedMutationResponseSelection;
        include?: RolePermissionsMaterializedMutationResponseSelection;
      };
  insert_role_permissions_materialized_one?:
    | boolean
    | {
        select?: RolePermissionsMaterializedSelection;
        include?: RolePermissionsMaterializedSelection;
      };
  insert_role_permissions_one?:
    | boolean
    | {
        select?: RolePermissionsSelection;
        include?: RolePermissionsSelection;
      };
  insert_scoring_weights?:
    | boolean
    | {
        select?: ScoringWeightsMutationResponseSelection;
        include?: ScoringWeightsMutationResponseSelection;
      };
  insert_scoring_weights_one?:
    | boolean
    | {
        select?: ScoringWeightsSelection;
        include?: ScoringWeightsSelection;
      };
  insert_searches?:
    | boolean
    | {
        select?: SearchesMutationResponseSelection;
        include?: SearchesMutationResponseSelection;
      };
  insert_searches_one?:
    | boolean
    | {
        select?: SearchesSelection;
        include?: SearchesSelection;
      };
  insert_social_media?:
    | boolean
    | {
        select?: SocialMediaMutationResponseSelection;
        include?: SocialMediaMutationResponseSelection;
      };
  insert_social_media_one?:
    | boolean
    | {
        select?: SocialMediaSelection;
        include?: SocialMediaSelection;
      };
  insert_spider_metrics?:
    | boolean
    | {
        select?: SpiderMetricsMutationResponseSelection;
        include?: SpiderMetricsMutationResponseSelection;
      };
  insert_spider_metrics_one?:
    | boolean
    | {
        select?: SpiderMetricsSelection;
        include?: SpiderMetricsSelection;
      };
  insert_strapi_migrations?:
    | boolean
    | {
        select?: StrapiMigrationsMutationResponseSelection;
        include?: StrapiMigrationsMutationResponseSelection;
      };
  insert_strapi_migrations_internal?:
    | boolean
    | {
        select?: StrapiMigrationsInternalMutationResponseSelection;
        include?: StrapiMigrationsInternalMutationResponseSelection;
      };
  insert_strapi_migrations_internal_one?:
    | boolean
    | {
        select?: StrapiMigrationsInternalSelection;
        include?: StrapiMigrationsInternalSelection;
      };
  insert_strapi_migrations_one?:
    | boolean
    | {
        select?: StrapiMigrationsSelection;
        include?: StrapiMigrationsSelection;
      };
  insert_table_maintenance_log?:
    | boolean
    | {
        select?: TableMaintenanceLogMutationResponseSelection;
        include?: TableMaintenanceLogMutationResponseSelection;
      };
  insert_table_maintenance_log_one?:
    | boolean
    | {
        select?: TableMaintenanceLogSelection;
        include?: TableMaintenanceLogSelection;
      };
  insert_table_query_performance?:
    | boolean
    | {
        select?: TableQueryPerformanceMutationResponseSelection;
        include?: TableQueryPerformanceMutationResponseSelection;
      };
  insert_table_query_performance_one?:
    | boolean
    | {
        select?: TableQueryPerformanceSelection;
        include?: TableQueryPerformanceSelection;
      };
  insert_table_sequence_usage?:
    | boolean
    | {
        select?: TableSequenceUsageMutationResponseSelection;
        include?: TableSequenceUsageMutationResponseSelection;
      };
  insert_table_sequence_usage_one?:
    | boolean
    | {
        select?: TableSequenceUsageSelection;
        include?: TableSequenceUsageSelection;
      };
  insert_table_statistics?:
    | boolean
    | {
        select?: TableStatisticsMutationResponseSelection;
        include?: TableStatisticsMutationResponseSelection;
      };
  insert_table_statistics_one?:
    | boolean
    | {
        select?: TableStatisticsSelection;
        include?: TableStatisticsSelection;
      };
  insert_tags?:
    | boolean
    | {
        select?: TagsMutationResponseSelection;
        include?: TagsMutationResponseSelection;
      };
  insert_tags_one?:
    | boolean
    | {
        select?: TagsSelection;
        include?: TagsSelection;
      };
  insert_user_metrics?:
    | boolean
    | {
        select?: UserMetricsMutationResponseSelection;
        include?: UserMetricsMutationResponseSelection;
      };
  insert_user_metrics_one?:
    | boolean
    | {
        select?: UserMetricsSelection;
        include?: UserMetricsSelection;
      };
  insert_user_profiles?:
    | boolean
    | {
        select?: UserProfilesMutationResponseSelection;
        include?: UserProfilesMutationResponseSelection;
      };
  insert_user_profiles_one?:
    | boolean
    | {
        select?: UserProfilesSelection;
        include?: UserProfilesSelection;
      };
  insert_votes?:
    | boolean
    | {
        select?: VotesMutationResponseSelection;
        include?: VotesMutationResponseSelection;
      };
  insert_votes_one?:
    | boolean
    | {
        select?: VotesSelection;
        include?: VotesSelection;
      };
  insert_workflows?:
    | boolean
    | {
        select?: WorkflowsMutationResponseSelection;
        include?: WorkflowsMutationResponseSelection;
      };
  insert_workflows_one?:
    | boolean
    | {
        select?: WorkflowsSelection;
        include?: WorkflowsSelection;
      };
  match_research?: boolean | boolean;
  update_ad_daily_metrics?:
    | boolean
    | {
        select?: AdDailyMetricsMutationResponseSelection;
        include?: AdDailyMetricsMutationResponseSelection;
      };
  update_ad_daily_metrics_by_pk?:
    | boolean
    | {
        select?: AdDailyMetricsSelection;
        include?: AdDailyMetricsSelection;
      };
  update_ad_daily_metrics_many?: boolean | boolean;
  update_ad_packages?:
    | boolean
    | {
        select?: AdPackagesMutationResponseSelection;
        include?: AdPackagesMutationResponseSelection;
      };
  update_ad_packages_by_pk?:
    | boolean
    | {
        select?: AdPackagesSelection;
        include?: AdPackagesSelection;
      };
  update_ad_packages_many?: boolean | boolean;
  update_ad_variants?:
    | boolean
    | {
        select?: AdVariantsMutationResponseSelection;
        include?: AdVariantsMutationResponseSelection;
      };
  update_ad_variants_by_pk?:
    | boolean
    | {
        select?: AdVariantsSelection;
        include?: AdVariantsSelection;
      };
  update_ad_variants_many?: boolean | boolean;
  update_addresses?:
    | boolean
    | {
        select?: AddressesMutationResponseSelection;
        include?: AddressesMutationResponseSelection;
      };
  update_addresses_by_pk?:
    | boolean
    | {
        select?: AddressesSelection;
        include?: AddressesSelection;
      };
  update_addresses_many?: boolean | boolean;
  update_ads?:
    | boolean
    | {
        select?: AdsMutationResponseSelection;
        include?: AdsMutationResponseSelection;
      };
  update_ads_by_pk?:
    | boolean
    | {
        select?: AdsSelection;
        include?: AdsSelection;
      };
  update_ads_many?: boolean | boolean;
  update_blacklisted_domains?:
    | boolean
    | {
        select?: BlacklistedDomainsMutationResponseSelection;
        include?: BlacklistedDomainsMutationResponseSelection;
      };
  update_blacklisted_domains_by_pk?:
    | boolean
    | {
        select?: BlacklistedDomainsSelection;
        include?: BlacklistedDomainsSelection;
      };
  update_blacklisted_domains_many?: boolean | boolean;
  update_blacklisted_urls?:
    | boolean
    | {
        select?: BlacklistedUrlsMutationResponseSelection;
        include?: BlacklistedUrlsMutationResponseSelection;
      };
  update_blacklisted_urls_by_pk?:
    | boolean
    | {
        select?: BlacklistedUrlsSelection;
        include?: BlacklistedUrlsSelection;
      };
  update_blacklisted_urls_many?: boolean | boolean;
  update_blocked_ips?:
    | boolean
    | {
        select?: BlockedIpsMutationResponseSelection;
        include?: BlockedIpsMutationResponseSelection;
      };
  update_blocked_ips_by_pk?:
    | boolean
    | {
        select?: BlockedIpsSelection;
        include?: BlockedIpsSelection;
      };
  update_blocked_ips_many?: boolean | boolean;
  update_bookmark_folders?:
    | boolean
    | {
        select?: BookmarkFoldersMutationResponseSelection;
        include?: BookmarkFoldersMutationResponseSelection;
      };
  update_bookmark_folders_by_pk?:
    | boolean
    | {
        select?: BookmarkFoldersSelection;
        include?: BookmarkFoldersSelection;
      };
  update_bookmark_folders_many?: boolean | boolean;
  update_bookmarks?:
    | boolean
    | {
        select?: BookmarksMutationResponseSelection;
        include?: BookmarksMutationResponseSelection;
      };
  update_bookmarks_by_pk?:
    | boolean
    | {
        select?: BookmarksSelection;
        include?: BookmarksSelection;
      };
  update_bookmarks_many?: boolean | boolean;
  update_business_domains?:
    | boolean
    | {
        select?: BusinessDomainsMutationResponseSelection;
        include?: BusinessDomainsMutationResponseSelection;
      };
  update_business_domains_by_pk?:
    | boolean
    | {
        select?: BusinessDomainsSelection;
        include?: BusinessDomainsSelection;
      };
  update_business_domains_many?: boolean | boolean;
  update_categories?:
    | boolean
    | {
        select?: CategoriesMutationResponseSelection;
        include?: CategoriesMutationResponseSelection;
      };
  update_categories_by_pk?:
    | boolean
    | {
        select?: CategoriesSelection;
        include?: CategoriesSelection;
      };
  update_categories_many?: boolean | boolean;
  update_categorized_urls?:
    | boolean
    | {
        select?: CategorizedUrlsMutationResponseSelection;
        include?: CategorizedUrlsMutationResponseSelection;
      };
  update_categorized_urls_by_pk?:
    | boolean
    | {
        select?: CategorizedUrlsSelection;
        include?: CategorizedUrlsSelection;
      };
  update_categorized_urls_many?: boolean | boolean;
  update_circuit_breaker_states?:
    | boolean
    | {
        select?: CircuitBreakerStatesMutationResponseSelection;
        include?: CircuitBreakerStatesMutationResponseSelection;
      };
  update_circuit_breaker_states_by_pk?:
    | boolean
    | {
        select?: CircuitBreakerStatesSelection;
        include?: CircuitBreakerStatesSelection;
      };
  update_circuit_breaker_states_many?: boolean | boolean;
  update_cities?:
    | boolean
    | {
        select?: CitiesMutationResponseSelection;
        include?: CitiesMutationResponseSelection;
      };
  update_cities_by_pk?:
    | boolean
    | {
        select?: CitiesSelection;
        include?: CitiesSelection;
      };
  update_cities_many?: boolean | boolean;
  update_comments?:
    | boolean
    | {
        select?: CommentsMutationResponseSelection;
        include?: CommentsMutationResponseSelection;
      };
  update_comments_by_pk?:
    | boolean
    | {
        select?: CommentsSelection;
        include?: CommentsSelection;
      };
  update_comments_many?: boolean | boolean;
  update_companies?:
    | boolean
    | {
        select?: CompaniesMutationResponseSelection;
        include?: CompaniesMutationResponseSelection;
      };
  update_companies_by_pk?:
    | boolean
    | {
        select?: CompaniesSelection;
        include?: CompaniesSelection;
      };
  update_companies_many?: boolean | boolean;
  update_company_contacts?:
    | boolean
    | {
        select?: CompanyContactsMutationResponseSelection;
        include?: CompanyContactsMutationResponseSelection;
      };
  update_company_contacts_by_pk?:
    | boolean
    | {
        select?: CompanyContactsSelection;
        include?: CompanyContactsSelection;
      };
  update_company_contacts_many?: boolean | boolean;
  update_company_employees?:
    | boolean
    | {
        select?: CompanyEmployeesMutationResponseSelection;
        include?: CompanyEmployeesMutationResponseSelection;
      };
  update_company_employees_by_pk?:
    | boolean
    | {
        select?: CompanyEmployeesSelection;
        include?: CompanyEmployeesSelection;
      };
  update_company_employees_many?: boolean | boolean;
  update_company_extras?:
    | boolean
    | {
        select?: CompanyExtrasMutationResponseSelection;
        include?: CompanyExtrasMutationResponseSelection;
      };
  update_company_extras_by_pk?:
    | boolean
    | {
        select?: CompanyExtrasSelection;
        include?: CompanyExtrasSelection;
      };
  update_company_extras_many?: boolean | boolean;
  update_company_metrics?:
    | boolean
    | {
        select?: CompanyMetricsMutationResponseSelection;
        include?: CompanyMetricsMutationResponseSelection;
      };
  update_company_metrics_by_pk?:
    | boolean
    | {
        select?: CompanyMetricsSelection;
        include?: CompanyMetricsSelection;
      };
  update_company_metrics_many?: boolean | boolean;
  update_contacts?:
    | boolean
    | {
        select?: ContactsMutationResponseSelection;
        include?: ContactsMutationResponseSelection;
      };
  update_contacts_by_pk?:
    | boolean
    | {
        select?: ContactsSelection;
        include?: ContactsSelection;
      };
  update_contacts_many?: boolean | boolean;
  update_content_categories?:
    | boolean
    | {
        select?: ContentCategoriesMutationResponseSelection;
        include?: ContentCategoriesMutationResponseSelection;
      };
  update_content_categories_by_pk?:
    | boolean
    | {
        select?: ContentCategoriesSelection;
        include?: ContentCategoriesSelection;
      };
  update_content_categories_many?: boolean | boolean;
  update_content_source_visits?:
    | boolean
    | {
        select?: ContentSourceVisitsMutationResponseSelection;
        include?: ContentSourceVisitsMutationResponseSelection;
      };
  update_content_source_visits_by_pk?:
    | boolean
    | {
        select?: ContentSourceVisitsSelection;
        include?: ContentSourceVisitsSelection;
      };
  update_content_source_visits_many?: boolean | boolean;
  update_content_sources?:
    | boolean
    | {
        select?: ContentSourcesMutationResponseSelection;
        include?: ContentSourcesMutationResponseSelection;
      };
  update_content_sources_by_pk?:
    | boolean
    | {
        select?: ContentSourcesSelection;
        include?: ContentSourcesSelection;
      };
  update_content_sources_many?: boolean | boolean;
  update_content_statuses?:
    | boolean
    | {
        select?: ContentStatusesMutationResponseSelection;
        include?: ContentStatusesMutationResponseSelection;
      };
  update_content_statuses_by_pk?:
    | boolean
    | {
        select?: ContentStatusesSelection;
        include?: ContentStatusesSelection;
      };
  update_content_statuses_many?: boolean | boolean;
  update_content_tags?:
    | boolean
    | {
        select?: ContentTagsMutationResponseSelection;
        include?: ContentTagsMutationResponseSelection;
      };
  update_content_tags_by_pk?:
    | boolean
    | {
        select?: ContentTagsSelection;
        include?: ContentTagsSelection;
      };
  update_content_tags_many?: boolean | boolean;
  update_contents?:
    | boolean
    | {
        select?: ContentsMutationResponseSelection;
        include?: ContentsMutationResponseSelection;
      };
  update_contents_by_pk?:
    | boolean
    | {
        select?: ContentsSelection;
        include?: ContentsSelection;
      };
  update_contents_many?: boolean | boolean;
  update_countries?:
    | boolean
    | {
        select?: CountriesMutationResponseSelection;
        include?: CountriesMutationResponseSelection;
      };
  update_countries_by_pk?:
    | boolean
    | {
        select?: CountriesSelection;
        include?: CountriesSelection;
      };
  update_countries_many?: boolean | boolean;
  update_customer_payments?:
    | boolean
    | {
        select?: CustomerPaymentsMutationResponseSelection;
        include?: CustomerPaymentsMutationResponseSelection;
      };
  update_customer_payments_by_pk?:
    | boolean
    | {
        select?: CustomerPaymentsSelection;
        include?: CustomerPaymentsSelection;
      };
  update_customer_payments_many?: boolean | boolean;
  update_customer_processed_webhooks?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksMutationResponseSelection;
        include?: CustomerProcessedWebhooksMutationResponseSelection;
      };
  update_customer_processed_webhooks_by_pk?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksSelection;
        include?: CustomerProcessedWebhooksSelection;
      };
  update_customer_processed_webhooks_many?: boolean | boolean;
  update_customer_refunds?:
    | boolean
    | {
        select?: CustomerRefundsMutationResponseSelection;
        include?: CustomerRefundsMutationResponseSelection;
      };
  update_customer_refunds_by_pk?:
    | boolean
    | {
        select?: CustomerRefundsSelection;
        include?: CustomerRefundsSelection;
      };
  update_customer_refunds_many?: boolean | boolean;
  update_customer_subscription_plans?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansMutationResponseSelection;
        include?: CustomerSubscriptionPlansMutationResponseSelection;
      };
  update_customer_subscription_plans_by_pk?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansSelection;
        include?: CustomerSubscriptionPlansSelection;
      };
  update_customer_subscription_plans_many?: boolean | boolean;
  update_customer_subscriptions?:
    | boolean
    | {
        select?: CustomerSubscriptionsMutationResponseSelection;
        include?: CustomerSubscriptionsMutationResponseSelection;
      };
  update_customer_subscriptions_by_pk?:
    | boolean
    | {
        select?: CustomerSubscriptionsSelection;
        include?: CustomerSubscriptionsSelection;
      };
  update_customer_subscriptions_many?: boolean | boolean;
  update_embedding_reviews?:
    | boolean
    | {
        select?: EmbeddingReviewsMutationResponseSelection;
        include?: EmbeddingReviewsMutationResponseSelection;
      };
  update_embedding_reviews_by_pk?:
    | boolean
    | {
        select?: EmbeddingReviewsSelection;
        include?: EmbeddingReviewsSelection;
      };
  update_embedding_reviews_many?: boolean | boolean;
  update_error_logs?:
    | boolean
    | {
        select?: ErrorLogsMutationResponseSelection;
        include?: ErrorLogsMutationResponseSelection;
      };
  update_error_logs_by_pk?:
    | boolean
    | {
        select?: ErrorLogsSelection;
        include?: ErrorLogsSelection;
      };
  update_error_logs_many?: boolean | boolean;
  update_feature_requests?:
    | boolean
    | {
        select?: FeatureRequestsMutationResponseSelection;
        include?: FeatureRequestsMutationResponseSelection;
      };
  update_feature_requests_by_pk?:
    | boolean
    | {
        select?: FeatureRequestsSelection;
        include?: FeatureRequestsSelection;
      };
  update_feature_requests_many?: boolean | boolean;
  update_feature_votes?:
    | boolean
    | {
        select?: FeatureVotesMutationResponseSelection;
        include?: FeatureVotesMutationResponseSelection;
      };
  update_feature_votes_by_pk?:
    | boolean
    | {
        select?: FeatureVotesSelection;
        include?: FeatureVotesSelection;
      };
  update_feature_votes_many?: boolean | boolean;
  update_feed_categories?:
    | boolean
    | {
        select?: FeedCategoriesMutationResponseSelection;
        include?: FeedCategoriesMutationResponseSelection;
      };
  update_feed_categories_by_pk?:
    | boolean
    | {
        select?: FeedCategoriesSelection;
        include?: FeedCategoriesSelection;
      };
  update_feed_categories_many?: boolean | boolean;
  update_feed_sources?:
    | boolean
    | {
        select?: FeedSourcesMutationResponseSelection;
        include?: FeedSourcesMutationResponseSelection;
      };
  update_feed_sources_by_pk?:
    | boolean
    | {
        select?: FeedSourcesSelection;
        include?: FeedSourcesSelection;
      };
  update_feed_sources_many?: boolean | boolean;
  update_feedbacks?:
    | boolean
    | {
        select?: FeedbacksMutationResponseSelection;
        include?: FeedbacksMutationResponseSelection;
      };
  update_feedbacks_by_pk?:
    | boolean
    | {
        select?: FeedbacksSelection;
        include?: FeedbacksSelection;
      };
  update_feedbacks_many?: boolean | boolean;
  update_feeds?:
    | boolean
    | {
        select?: FeedsMutationResponseSelection;
        include?: FeedsMutationResponseSelection;
      };
  update_feeds_by_pk?:
    | boolean
    | {
        select?: FeedsSelection;
        include?: FeedsSelection;
      };
  update_feeds_many?: boolean | boolean;
  update_follows?:
    | boolean
    | {
        select?: FollowsMutationResponseSelection;
        include?: FollowsMutationResponseSelection;
      };
  update_follows_by_pk?:
    | boolean
    | {
        select?: FollowsSelection;
        include?: FollowsSelection;
      };
  update_follows_many?: boolean | boolean;
  update_metric_definitions?:
    | boolean
    | {
        select?: MetricDefinitionsMutationResponseSelection;
        include?: MetricDefinitionsMutationResponseSelection;
      };
  update_metric_definitions_by_pk?:
    | boolean
    | {
        select?: MetricDefinitionsSelection;
        include?: MetricDefinitionsSelection;
      };
  update_metric_definitions_many?: boolean | boolean;
  update_news?:
    | boolean
    | {
        select?: NewsMutationResponseSelection;
        include?: NewsMutationResponseSelection;
      };
  update_news_by_pk?:
    | boolean
    | {
        select?: NewsSelection;
        include?: NewsSelection;
      };
  update_news_many?: boolean | boolean;
  update_news_summaries?:
    | boolean
    | {
        select?: NewsSummariesMutationResponseSelection;
        include?: NewsSummariesMutationResponseSelection;
      };
  update_news_summaries_by_pk?:
    | boolean
    | {
        select?: NewsSummariesSelection;
        include?: NewsSummariesSelection;
      };
  update_news_summaries_many?: boolean | boolean;
  update_news_tags?:
    | boolean
    | {
        select?: NewsTagsMutationResponseSelection;
        include?: NewsTagsMutationResponseSelection;
      };
  update_news_tags_by_pk?:
    | boolean
    | {
        select?: NewsTagsSelection;
        include?: NewsTagsSelection;
      };
  update_news_tags_many?: boolean | boolean;
  update_newsletters?:
    | boolean
    | {
        select?: NewslettersMutationResponseSelection;
        include?: NewslettersMutationResponseSelection;
      };
  update_newsletters_by_pk?:
    | boolean
    | {
        select?: NewslettersSelection;
        include?: NewslettersSelection;
      };
  update_newsletters_many?: boolean | boolean;
  update_payment_providers?:
    | boolean
    | {
        select?: PaymentProvidersMutationResponseSelection;
        include?: PaymentProvidersMutationResponseSelection;
      };
  update_payment_providers_by_pk?:
    | boolean
    | {
        select?: PaymentProvidersSelection;
        include?: PaymentProvidersSelection;
      };
  update_payment_providers_many?: boolean | boolean;
  update_plan_permissions?:
    | boolean
    | {
        select?: PlanPermissionsMutationResponseSelection;
        include?: PlanPermissionsMutationResponseSelection;
      };
  update_plan_permissions_by_pk?:
    | boolean
    | {
        select?: PlanPermissionsSelection;
        include?: PlanPermissionsSelection;
      };
  update_plan_permissions_many?: boolean | boolean;
  update_recent_errors?:
    | boolean
    | {
        select?: RecentErrorsMutationResponseSelection;
        include?: RecentErrorsMutationResponseSelection;
      };
  update_recent_errors_many?: boolean | boolean;
  update_referrals?:
    | boolean
    | {
        select?: ReferralsMutationResponseSelection;
        include?: ReferralsMutationResponseSelection;
      };
  update_referrals_by_pk?:
    | boolean
    | {
        select?: ReferralsSelection;
        include?: ReferralsSelection;
      };
  update_referrals_many?: boolean | boolean;
  update_referrer_blocks?:
    | boolean
    | {
        select?: ReferrerBlocksMutationResponseSelection;
        include?: ReferrerBlocksMutationResponseSelection;
      };
  update_referrer_blocks_by_pk?:
    | boolean
    | {
        select?: ReferrerBlocksSelection;
        include?: ReferrerBlocksSelection;
      };
  update_referrer_blocks_many?: boolean | boolean;
  update_research?:
    | boolean
    | {
        select?: ResearchMutationResponseSelection;
        include?: ResearchMutationResponseSelection;
      };
  update_research_by_pk?:
    | boolean
    | {
        select?: ResearchSelection;
        include?: ResearchSelection;
      };
  update_research_embeddings?:
    | boolean
    | {
        select?: ResearchEmbeddingsMutationResponseSelection;
        include?: ResearchEmbeddingsMutationResponseSelection;
      };
  update_research_embeddings_by_pk?:
    | boolean
    | {
        select?: ResearchEmbeddingsSelection;
        include?: ResearchEmbeddingsSelection;
      };
  update_research_embeddings_many?: boolean | boolean;
  update_research_many?: boolean | boolean;
  update_responses?:
    | boolean
    | {
        select?: ResponsesMutationResponseSelection;
        include?: ResponsesMutationResponseSelection;
      };
  update_responses_by_pk?:
    | boolean
    | {
        select?: ResponsesSelection;
        include?: ResponsesSelection;
      };
  update_responses_many?: boolean | boolean;
  update_role_hierarchy?:
    | boolean
    | {
        select?: RoleHierarchyMutationResponseSelection;
        include?: RoleHierarchyMutationResponseSelection;
      };
  update_role_hierarchy_by_pk?:
    | boolean
    | {
        select?: RoleHierarchySelection;
        include?: RoleHierarchySelection;
      };
  update_role_hierarchy_many?: boolean | boolean;
  update_role_permissions?:
    | boolean
    | {
        select?: RolePermissionsMutationResponseSelection;
        include?: RolePermissionsMutationResponseSelection;
      };
  update_role_permissions_by_pk?:
    | boolean
    | {
        select?: RolePermissionsSelection;
        include?: RolePermissionsSelection;
      };
  update_role_permissions_many?: boolean | boolean;
  update_role_permissions_materialized?:
    | boolean
    | {
        select?: RolePermissionsMaterializedMutationResponseSelection;
        include?: RolePermissionsMaterializedMutationResponseSelection;
      };
  update_role_permissions_materialized_by_pk?:
    | boolean
    | {
        select?: RolePermissionsMaterializedSelection;
        include?: RolePermissionsMaterializedSelection;
      };
  update_role_permissions_materialized_many?: boolean | boolean;
  update_scoring_weights?:
    | boolean
    | {
        select?: ScoringWeightsMutationResponseSelection;
        include?: ScoringWeightsMutationResponseSelection;
      };
  update_scoring_weights_by_pk?:
    | boolean
    | {
        select?: ScoringWeightsSelection;
        include?: ScoringWeightsSelection;
      };
  update_scoring_weights_many?: boolean | boolean;
  update_searches?:
    | boolean
    | {
        select?: SearchesMutationResponseSelection;
        include?: SearchesMutationResponseSelection;
      };
  update_searches_by_pk?:
    | boolean
    | {
        select?: SearchesSelection;
        include?: SearchesSelection;
      };
  update_searches_many?: boolean | boolean;
  update_social_media?:
    | boolean
    | {
        select?: SocialMediaMutationResponseSelection;
        include?: SocialMediaMutationResponseSelection;
      };
  update_social_media_by_pk?:
    | boolean
    | {
        select?: SocialMediaSelection;
        include?: SocialMediaSelection;
      };
  update_social_media_many?: boolean | boolean;
  update_spider_metrics?:
    | boolean
    | {
        select?: SpiderMetricsMutationResponseSelection;
        include?: SpiderMetricsMutationResponseSelection;
      };
  update_spider_metrics_by_pk?:
    | boolean
    | {
        select?: SpiderMetricsSelection;
        include?: SpiderMetricsSelection;
      };
  update_spider_metrics_many?: boolean | boolean;
  update_strapi_migrations?:
    | boolean
    | {
        select?: StrapiMigrationsMutationResponseSelection;
        include?: StrapiMigrationsMutationResponseSelection;
      };
  update_strapi_migrations_by_pk?:
    | boolean
    | {
        select?: StrapiMigrationsSelection;
        include?: StrapiMigrationsSelection;
      };
  update_strapi_migrations_internal?:
    | boolean
    | {
        select?: StrapiMigrationsInternalMutationResponseSelection;
        include?: StrapiMigrationsInternalMutationResponseSelection;
      };
  update_strapi_migrations_internal_by_pk?:
    | boolean
    | {
        select?: StrapiMigrationsInternalSelection;
        include?: StrapiMigrationsInternalSelection;
      };
  update_strapi_migrations_internal_many?: boolean | boolean;
  update_strapi_migrations_many?: boolean | boolean;
  update_table_maintenance_log?:
    | boolean
    | {
        select?: TableMaintenanceLogMutationResponseSelection;
        include?: TableMaintenanceLogMutationResponseSelection;
      };
  update_table_maintenance_log_by_pk?:
    | boolean
    | {
        select?: TableMaintenanceLogSelection;
        include?: TableMaintenanceLogSelection;
      };
  update_table_maintenance_log_many?: boolean | boolean;
  update_table_query_performance?:
    | boolean
    | {
        select?: TableQueryPerformanceMutationResponseSelection;
        include?: TableQueryPerformanceMutationResponseSelection;
      };
  update_table_query_performance_many?: boolean | boolean;
  update_table_sequence_usage?:
    | boolean
    | {
        select?: TableSequenceUsageMutationResponseSelection;
        include?: TableSequenceUsageMutationResponseSelection;
      };
  update_table_sequence_usage_many?: boolean | boolean;
  update_table_statistics?:
    | boolean
    | {
        select?: TableStatisticsMutationResponseSelection;
        include?: TableStatisticsMutationResponseSelection;
      };
  update_table_statistics_by_pk?:
    | boolean
    | {
        select?: TableStatisticsSelection;
        include?: TableStatisticsSelection;
      };
  update_table_statistics_many?: boolean | boolean;
  update_tags?:
    | boolean
    | {
        select?: TagsMutationResponseSelection;
        include?: TagsMutationResponseSelection;
      };
  update_tags_by_pk?:
    | boolean
    | {
        select?: TagsSelection;
        include?: TagsSelection;
      };
  update_tags_many?: boolean | boolean;
  update_user_metrics?:
    | boolean
    | {
        select?: UserMetricsMutationResponseSelection;
        include?: UserMetricsMutationResponseSelection;
      };
  update_user_metrics_by_pk?:
    | boolean
    | {
        select?: UserMetricsSelection;
        include?: UserMetricsSelection;
      };
  update_user_metrics_many?: boolean | boolean;
  update_user_profiles?:
    | boolean
    | {
        select?: UserProfilesMutationResponseSelection;
        include?: UserProfilesMutationResponseSelection;
      };
  update_user_profiles_by_pk?:
    | boolean
    | {
        select?: UserProfilesSelection;
        include?: UserProfilesSelection;
      };
  update_user_profiles_many?: boolean | boolean;
  update_votes?:
    | boolean
    | {
        select?: VotesMutationResponseSelection;
        include?: VotesMutationResponseSelection;
      };
  update_votes_by_pk?:
    | boolean
    | {
        select?: VotesSelection;
        include?: VotesSelection;
      };
  update_votes_many?: boolean | boolean;
  update_workflows?:
    | boolean
    | {
        select?: WorkflowsMutationResponseSelection;
        include?: WorkflowsMutationResponseSelection;
      };
  update_workflows_by_pk?:
    | boolean
    | {
        select?: WorkflowsSelection;
        include?: WorkflowsSelection;
      };
  update_workflows_many?: boolean | boolean;
}

export const includeMutationRoot = <T extends MutationRootSelection>(
  include: T,
) => include;

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

export interface NewsSelection {
  author?: boolean | boolean;
  body?: boolean | boolean;
  category?:
    | boolean
    | {
        select?: CategoriesSelection;
        include?: CategoriesSelection;
      };
  category_id?: boolean | boolean;
  company?:
    | boolean
    | {
        select?: CompaniesSelection;
        include?: CompaniesSelection;
      };
  company_id?: boolean | boolean;
  content?: boolean | boolean;
  content_source?:
    | boolean
    | {
        select?: ContentSourcesSelection;
        include?: ContentSourcesSelection;
      };
  content_source_id?: boolean | boolean;
  content_status?: boolean | boolean;
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  failed_count?: boolean | boolean;
  featured_image?: boolean | boolean;
  has_summary?: boolean | boolean;
  hash?: boolean | boolean;
  id?: boolean | boolean;
  keywords?: boolean | boolean;
  news_summaries?: boolean | boolean;
  news_summaries_aggregate?: boolean | boolean;
  published_at?: boolean | boolean;
  scrape_frequency?: boolean | boolean;
  scraped_at?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeNews = <T extends NewsSelection>(include: T) => include;

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

export interface NewsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: NewsAggregateFieldsSelection;
        include?: NewsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeNewsAggregate = <T extends NewsAggregateSelection>(
  include: T,
) => include;

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

export interface NewsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: NewsAvgFieldsSelection;
        include?: NewsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: NewsMaxFieldsSelection;
        include?: NewsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: NewsMinFieldsSelection;
        include?: NewsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: NewsStddevFieldsSelection;
        include?: NewsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: NewsStddevPopFieldsSelection;
        include?: NewsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: NewsStddevSampFieldsSelection;
        include?: NewsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: NewsSumFieldsSelection;
        include?: NewsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: NewsVarPopFieldsSelection;
        include?: NewsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: NewsVarSampFieldsSelection;
        include?: NewsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: NewsVarianceFieldsSelection;
        include?: NewsVarianceFieldsSelection;
      };
}

export const includeNewsAggregateFields = <
  T extends NewsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsAvgFieldsSelection {
  category_id?: boolean | boolean;
  content_source_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
}

export const includeNewsAvgFields = <T extends NewsAvgFieldsSelection>(
  include: T,
) => include;

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

export interface NewsDetailsSelection {
  author?: boolean | boolean;
  bookmark_count?: boolean | boolean;
  categories?: boolean | boolean;
  company_logo?: boolean | boolean;
  company_name?: boolean | boolean;
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  featured_image?: boolean | boolean;
  hot_score?: boolean | boolean;
  id?: boolean | boolean;
  published_at?: boolean | boolean;
  summaries?: boolean | boolean;
  tags?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
  vote_count?: boolean | boolean;
}

export const includeNewsDetails = <T extends NewsDetailsSelection>(
  include: T,
) => include;

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

export interface NewsDetailsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: NewsDetailsAggregateFieldsSelection;
        include?: NewsDetailsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeNewsDetailsAggregate = <
  T extends NewsDetailsAggregateSelection,
>(
  include: T,
) => include;

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

export interface NewsDetailsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: NewsDetailsAvgFieldsSelection;
        include?: NewsDetailsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: NewsDetailsMaxFieldsSelection;
        include?: NewsDetailsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: NewsDetailsMinFieldsSelection;
        include?: NewsDetailsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: NewsDetailsStddevFieldsSelection;
        include?: NewsDetailsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: NewsDetailsStddevPopFieldsSelection;
        include?: NewsDetailsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: NewsDetailsStddevSampFieldsSelection;
        include?: NewsDetailsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: NewsDetailsSumFieldsSelection;
        include?: NewsDetailsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: NewsDetailsVarPopFieldsSelection;
        include?: NewsDetailsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: NewsDetailsVarSampFieldsSelection;
        include?: NewsDetailsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: NewsDetailsVarianceFieldsSelection;
        include?: NewsDetailsVarianceFieldsSelection;
      };
}

export const includeNewsDetailsAggregateFields = <
  T extends NewsDetailsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsDetailsAvgFieldsSelection {
  bookmark_count?: boolean | boolean;
  hot_score?: boolean | boolean;
  vote_count?: boolean | boolean;
}

export const includeNewsDetailsAvgFields = <
  T extends NewsDetailsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsDetailsMaxFieldsSelection {
  author?: boolean | boolean;
  bookmark_count?: boolean | boolean;
  company_logo?: boolean | boolean;
  company_name?: boolean | boolean;
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  featured_image?: boolean | boolean;
  hot_score?: boolean | boolean;
  id?: boolean | boolean;
  published_at?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
  vote_count?: boolean | boolean;
}

export const includeNewsDetailsMaxFields = <
  T extends NewsDetailsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsDetailsMinFieldsSelection {
  author?: boolean | boolean;
  bookmark_count?: boolean | boolean;
  company_logo?: boolean | boolean;
  company_name?: boolean | boolean;
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  featured_image?: boolean | boolean;
  hot_score?: boolean | boolean;
  id?: boolean | boolean;
  published_at?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
  vote_count?: boolean | boolean;
}

export const includeNewsDetailsMinFields = <
  T extends NewsDetailsMinFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsDetailsStddevFieldsSelection {
  bookmark_count?: boolean | boolean;
  hot_score?: boolean | boolean;
  vote_count?: boolean | boolean;
}

export const includeNewsDetailsStddevFields = <
  T extends NewsDetailsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsDetailsStddevPopFieldsSelection {
  bookmark_count?: boolean | boolean;
  hot_score?: boolean | boolean;
  vote_count?: boolean | boolean;
}

export const includeNewsDetailsStddevPopFields = <
  T extends NewsDetailsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsDetailsStddevSampFieldsSelection {
  bookmark_count?: boolean | boolean;
  hot_score?: boolean | boolean;
  vote_count?: boolean | boolean;
}

export const includeNewsDetailsStddevSampFields = <
  T extends NewsDetailsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsDetailsSumFieldsSelection {
  bookmark_count?: boolean | boolean;
  hot_score?: boolean | boolean;
  vote_count?: boolean | boolean;
}

export const includeNewsDetailsSumFields = <
  T extends NewsDetailsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsDetailsVarPopFieldsSelection {
  bookmark_count?: boolean | boolean;
  hot_score?: boolean | boolean;
  vote_count?: boolean | boolean;
}

export const includeNewsDetailsVarPopFields = <
  T extends NewsDetailsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsDetailsVarSampFieldsSelection {
  bookmark_count?: boolean | boolean;
  hot_score?: boolean | boolean;
  vote_count?: boolean | boolean;
}

export const includeNewsDetailsVarSampFields = <
  T extends NewsDetailsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsDetailsVarianceFieldsSelection {
  bookmark_count?: boolean | boolean;
  hot_score?: boolean | boolean;
  vote_count?: boolean | boolean;
}

export const includeNewsDetailsVarianceFields = <
  T extends NewsDetailsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsMaxFieldsSelection {
  author?: boolean | boolean;
  body?: boolean | boolean;
  category_id?: boolean | boolean;
  company_id?: boolean | boolean;
  content_source_id?: boolean | boolean;
  content_status?: boolean | boolean;
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  failed_count?: boolean | boolean;
  featured_image?: boolean | boolean;
  hash?: boolean | boolean;
  id?: boolean | boolean;
  published_at?: boolean | boolean;
  scrape_frequency?: boolean | boolean;
  scraped_at?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeNewsMaxFields = <T extends NewsMaxFieldsSelection>(
  include: T,
) => include;

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

export interface NewsMinFieldsSelection {
  author?: boolean | boolean;
  body?: boolean | boolean;
  category_id?: boolean | boolean;
  company_id?: boolean | boolean;
  content_source_id?: boolean | boolean;
  content_status?: boolean | boolean;
  created_at?: boolean | boolean;
  description?: boolean | boolean;
  failed_count?: boolean | boolean;
  featured_image?: boolean | boolean;
  hash?: boolean | boolean;
  id?: boolean | boolean;
  published_at?: boolean | boolean;
  scrape_frequency?: boolean | boolean;
  scraped_at?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeNewsMinFields = <T extends NewsMinFieldsSelection>(
  include: T,
) => include;

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

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

export const includeNewsMutationResponse = <
  T extends NewsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface NewsStddevFieldsSelection {
  category_id?: boolean | boolean;
  content_source_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
}

export const includeNewsStddevFields = <T extends NewsStddevFieldsSelection>(
  include: T,
) => include;

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

export interface NewsStddevPopFieldsSelection {
  category_id?: boolean | boolean;
  content_source_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
}

export const includeNewsStddevPopFields = <
  T extends NewsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsStddevSampFieldsSelection {
  category_id?: boolean | boolean;
  content_source_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
}

export const includeNewsStddevSampFields = <
  T extends NewsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsSumFieldsSelection {
  category_id?: boolean | boolean;
  content_source_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
}

export const includeNewsSumFields = <T extends NewsSumFieldsSelection>(
  include: T,
) => include;

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

export interface NewsSummariesSelection {
  complexity_level?: boolean | boolean;
  created_at?: boolean | boolean;
  embedding?: boolean | boolean;
  id?: boolean | boolean;
  is_current?: boolean | boolean;
  news?: boolean | boolean;
  news_id?: boolean | boolean;
  summary?: boolean | boolean;
  updated_at?: boolean | boolean;
  version?: boolean | boolean;
}

export const includeNewsSummaries = <T extends NewsSummariesSelection>(
  include: T,
) => include;

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

export interface NewsSummariesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: NewsSummariesAggregateFieldsSelection;
        include?: NewsSummariesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeNewsSummariesAggregate = <
  T extends NewsSummariesAggregateSelection,
>(
  include: T,
) => include;

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

export interface NewsSummariesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: NewsSummariesAvgFieldsSelection;
        include?: NewsSummariesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: NewsSummariesMaxFieldsSelection;
        include?: NewsSummariesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: NewsSummariesMinFieldsSelection;
        include?: NewsSummariesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: NewsSummariesStddevFieldsSelection;
        include?: NewsSummariesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: NewsSummariesStddevPopFieldsSelection;
        include?: NewsSummariesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: NewsSummariesStddevSampFieldsSelection;
        include?: NewsSummariesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: NewsSummariesSumFieldsSelection;
        include?: NewsSummariesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: NewsSummariesVarPopFieldsSelection;
        include?: NewsSummariesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: NewsSummariesVarSampFieldsSelection;
        include?: NewsSummariesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: NewsSummariesVarianceFieldsSelection;
        include?: NewsSummariesVarianceFieldsSelection;
      };
}

export const includeNewsSummariesAggregateFields = <
  T extends NewsSummariesAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsSummariesAvgFieldsSelection {
  version?: boolean | boolean;
}

export const includeNewsSummariesAvgFields = <
  T extends NewsSummariesAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsSummariesMaxFieldsSelection {
  complexity_level?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  news_id?: boolean | boolean;
  summary?: boolean | boolean;
  updated_at?: boolean | boolean;
  version?: boolean | boolean;
}

export const includeNewsSummariesMaxFields = <
  T extends NewsSummariesMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsSummariesMinFieldsSelection {
  complexity_level?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  news_id?: boolean | boolean;
  summary?: boolean | boolean;
  updated_at?: boolean | boolean;
  version?: boolean | boolean;
}

export const includeNewsSummariesMinFields = <
  T extends NewsSummariesMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeNewsSummariesMutationResponse = <
  T extends NewsSummariesMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface NewsSummariesStddevFieldsSelection {
  version?: boolean | boolean;
}

export const includeNewsSummariesStddevFields = <
  T extends NewsSummariesStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsSummariesStddevPopFieldsSelection {
  version?: boolean | boolean;
}

export const includeNewsSummariesStddevPopFields = <
  T extends NewsSummariesStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsSummariesStddevSampFieldsSelection {
  version?: boolean | boolean;
}

export const includeNewsSummariesStddevSampFields = <
  T extends NewsSummariesStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsSummariesSumFieldsSelection {
  version?: boolean | boolean;
}

export const includeNewsSummariesSumFields = <
  T extends NewsSummariesSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsSummariesVarPopFieldsSelection {
  version?: boolean | boolean;
}

export const includeNewsSummariesVarPopFields = <
  T extends NewsSummariesVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsSummariesVarSampFieldsSelection {
  version?: boolean | boolean;
}

export const includeNewsSummariesVarSampFields = <
  T extends NewsSummariesVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsSummariesVarianceFieldsSelection {
  version?: boolean | boolean;
}

export const includeNewsSummariesVarianceFields = <
  T extends NewsSummariesVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsTagsSelection {
  id?: boolean | boolean;
  news_id?: boolean | boolean;
  tag?: boolean | boolean;
  tag_id?: boolean | boolean;
}

export const includeNewsTags = <T extends NewsTagsSelection>(include: T) =>
  include;

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

export interface NewsTagsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: NewsTagsAggregateFieldsSelection;
        include?: NewsTagsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeNewsTagsAggregate = <T extends NewsTagsAggregateSelection>(
  include: T,
) => include;

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

export interface NewsTagsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: NewsTagsAvgFieldsSelection;
        include?: NewsTagsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: NewsTagsMaxFieldsSelection;
        include?: NewsTagsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: NewsTagsMinFieldsSelection;
        include?: NewsTagsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: NewsTagsStddevFieldsSelection;
        include?: NewsTagsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: NewsTagsStddevPopFieldsSelection;
        include?: NewsTagsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: NewsTagsStddevSampFieldsSelection;
        include?: NewsTagsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: NewsTagsSumFieldsSelection;
        include?: NewsTagsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: NewsTagsVarPopFieldsSelection;
        include?: NewsTagsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: NewsTagsVarSampFieldsSelection;
        include?: NewsTagsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: NewsTagsVarianceFieldsSelection;
        include?: NewsTagsVarianceFieldsSelection;
      };
}

export const includeNewsTagsAggregateFields = <
  T extends NewsTagsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsTagsAvgFieldsSelection {
  id?: boolean | boolean;
  tag_id?: boolean | boolean;
}

export const includeNewsTagsAvgFields = <T extends NewsTagsAvgFieldsSelection>(
  include: T,
) => include;

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

export interface NewsTagsMaxFieldsSelection {
  id?: boolean | boolean;
  news_id?: boolean | boolean;
  tag_id?: boolean | boolean;
}

export const includeNewsTagsMaxFields = <T extends NewsTagsMaxFieldsSelection>(
  include: T,
) => include;

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

export interface NewsTagsMinFieldsSelection {
  id?: boolean | boolean;
  news_id?: boolean | boolean;
  tag_id?: boolean | boolean;
}

export const includeNewsTagsMinFields = <T extends NewsTagsMinFieldsSelection>(
  include: T,
) => include;

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

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

export const includeNewsTagsMutationResponse = <
  T extends NewsTagsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface NewsTagsStddevFieldsSelection {
  id?: boolean | boolean;
  tag_id?: boolean | boolean;
}

export const includeNewsTagsStddevFields = <
  T extends NewsTagsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsTagsStddevPopFieldsSelection {
  id?: boolean | boolean;
  tag_id?: boolean | boolean;
}

export const includeNewsTagsStddevPopFields = <
  T extends NewsTagsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsTagsStddevSampFieldsSelection {
  id?: boolean | boolean;
  tag_id?: boolean | boolean;
}

export const includeNewsTagsStddevSampFields = <
  T extends NewsTagsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsTagsSumFieldsSelection {
  id?: boolean | boolean;
  tag_id?: boolean | boolean;
}

export const includeNewsTagsSumFields = <T extends NewsTagsSumFieldsSelection>(
  include: T,
) => include;

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

export interface NewsTagsVarPopFieldsSelection {
  id?: boolean | boolean;
  tag_id?: boolean | boolean;
}

export const includeNewsTagsVarPopFields = <
  T extends NewsTagsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsTagsVarSampFieldsSelection {
  id?: boolean | boolean;
  tag_id?: boolean | boolean;
}

export const includeNewsTagsVarSampFields = <
  T extends NewsTagsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsTagsVarianceFieldsSelection {
  id?: boolean | boolean;
  tag_id?: boolean | boolean;
}

export const includeNewsTagsVarianceFields = <
  T extends NewsTagsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewsVarPopFieldsSelection {
  category_id?: boolean | boolean;
  content_source_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
}

export const includeNewsVarPopFields = <T extends NewsVarPopFieldsSelection>(
  include: T,
) => include;

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

export interface NewsVarSampFieldsSelection {
  category_id?: boolean | boolean;
  content_source_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
}

export const includeNewsVarSampFields = <T extends NewsVarSampFieldsSelection>(
  include: T,
) => include;

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

export interface NewsVarianceFieldsSelection {
  category_id?: boolean | boolean;
  content_source_id?: boolean | boolean;
  failed_count?: boolean | boolean;
  hash?: boolean | boolean;
}

export const includeNewsVarianceFields = <
  T extends NewsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewslettersSelection {
  content?: boolean | boolean;
  content_status?: boolean | boolean;
  created_at?: boolean | boolean;
  end_date?: boolean | boolean;
  frequency?: boolean | boolean;
  generated_content?: boolean | boolean;
  id?: boolean | boolean;
  start_date?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeNewsletters = <T extends NewslettersSelection>(
  include: T,
) => include;

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

export interface NewslettersAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: NewslettersAggregateFieldsSelection;
        include?: NewslettersAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeNewslettersAggregate = <
  T extends NewslettersAggregateSelection,
>(
  include: T,
) => include;

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

export interface NewslettersAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: NewslettersMaxFieldsSelection;
        include?: NewslettersMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: NewslettersMinFieldsSelection;
        include?: NewslettersMinFieldsSelection;
      };
}

export const includeNewslettersAggregateFields = <
  T extends NewslettersAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewslettersMaxFieldsSelection {
  content_status?: boolean | boolean;
  created_at?: boolean | boolean;
  end_date?: boolean | boolean;
  frequency?: boolean | boolean;
  generated_content?: boolean | boolean;
  id?: boolean | boolean;
  start_date?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeNewslettersMaxFields = <
  T extends NewslettersMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface NewslettersMinFieldsSelection {
  content_status?: boolean | boolean;
  created_at?: boolean | boolean;
  end_date?: boolean | boolean;
  frequency?: boolean | boolean;
  generated_content?: boolean | boolean;
  id?: boolean | boolean;
  start_date?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeNewslettersMinFields = <
  T extends NewslettersMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeNewslettersMutationResponse = <
  T extends NewslettersMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface PaymentProvidersSelection {
  created_at?: boolean | boolean;
  customer_payments?: boolean | boolean;
  customer_payments_aggregate?: boolean | boolean;
  customer_subscriptions?: boolean | boolean;
  customer_subscriptions_aggregate?: boolean | boolean;
  id?: boolean | boolean;
  is_active?: boolean | boolean;
  name?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includePaymentProviders = <T extends PaymentProvidersSelection>(
  include: T,
) => include;

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

export interface PaymentProvidersAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: PaymentProvidersAggregateFieldsSelection;
        include?: PaymentProvidersAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includePaymentProvidersAggregate = <
  T extends PaymentProvidersAggregateSelection,
>(
  include: T,
) => include;

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

export interface PaymentProvidersAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: PaymentProvidersAvgFieldsSelection;
        include?: PaymentProvidersAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: PaymentProvidersMaxFieldsSelection;
        include?: PaymentProvidersMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: PaymentProvidersMinFieldsSelection;
        include?: PaymentProvidersMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: PaymentProvidersStddevFieldsSelection;
        include?: PaymentProvidersStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: PaymentProvidersStddevPopFieldsSelection;
        include?: PaymentProvidersStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: PaymentProvidersStddevSampFieldsSelection;
        include?: PaymentProvidersStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: PaymentProvidersSumFieldsSelection;
        include?: PaymentProvidersSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: PaymentProvidersVarPopFieldsSelection;
        include?: PaymentProvidersVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: PaymentProvidersVarSampFieldsSelection;
        include?: PaymentProvidersVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: PaymentProvidersVarianceFieldsSelection;
        include?: PaymentProvidersVarianceFieldsSelection;
      };
}

export const includePaymentProvidersAggregateFields = <
  T extends PaymentProvidersAggregateFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePaymentProvidersAvgFields = <
  T extends PaymentProvidersAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface PaymentProvidersMaxFieldsSelection {
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includePaymentProvidersMaxFields = <
  T extends PaymentProvidersMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface PaymentProvidersMinFieldsSelection {
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includePaymentProvidersMinFields = <
  T extends PaymentProvidersMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePaymentProvidersMutationResponse = <
  T extends PaymentProvidersMutationResponseSelection,
>(
  include: T,
) => include;

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

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

export const includePaymentProvidersStddevFields = <
  T extends PaymentProvidersStddevFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePaymentProvidersStddevPopFields = <
  T extends PaymentProvidersStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePaymentProvidersStddevSampFields = <
  T extends PaymentProvidersStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePaymentProvidersSumFields = <
  T extends PaymentProvidersSumFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePaymentProvidersVarPopFields = <
  T extends PaymentProvidersVarPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePaymentProvidersVarSampFields = <
  T extends PaymentProvidersVarSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePaymentProvidersVarianceFields = <
  T extends PaymentProvidersVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface PlanPermissionsSelection {
  feature?: boolean | boolean;
  id?: boolean | boolean;
  plan?: boolean | boolean;
}

export const includePlanPermissions = <T extends PlanPermissionsSelection>(
  include: T,
) => include;

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

export interface PlanPermissionsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: PlanPermissionsAggregateFieldsSelection;
        include?: PlanPermissionsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includePlanPermissionsAggregate = <
  T extends PlanPermissionsAggregateSelection,
>(
  include: T,
) => include;

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

export interface PlanPermissionsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: PlanPermissionsAvgFieldsSelection;
        include?: PlanPermissionsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: PlanPermissionsMaxFieldsSelection;
        include?: PlanPermissionsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: PlanPermissionsMinFieldsSelection;
        include?: PlanPermissionsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: PlanPermissionsStddevFieldsSelection;
        include?: PlanPermissionsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: PlanPermissionsStddevPopFieldsSelection;
        include?: PlanPermissionsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: PlanPermissionsStddevSampFieldsSelection;
        include?: PlanPermissionsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: PlanPermissionsSumFieldsSelection;
        include?: PlanPermissionsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: PlanPermissionsVarPopFieldsSelection;
        include?: PlanPermissionsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: PlanPermissionsVarSampFieldsSelection;
        include?: PlanPermissionsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: PlanPermissionsVarianceFieldsSelection;
        include?: PlanPermissionsVarianceFieldsSelection;
      };
}

export const includePlanPermissionsAggregateFields = <
  T extends PlanPermissionsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePlanPermissionsAvgFields = <
  T extends PlanPermissionsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface PlanPermissionsMaxFieldsSelection {
  feature?: boolean | boolean;
  id?: boolean | boolean;
  plan?: boolean | boolean;
}

export const includePlanPermissionsMaxFields = <
  T extends PlanPermissionsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface PlanPermissionsMinFieldsSelection {
  feature?: boolean | boolean;
  id?: boolean | boolean;
  plan?: boolean | boolean;
}

export const includePlanPermissionsMinFields = <
  T extends PlanPermissionsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePlanPermissionsMutationResponse = <
  T extends PlanPermissionsMutationResponseSelection,
>(
  include: T,
) => include;

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

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

export const includePlanPermissionsStddevFields = <
  T extends PlanPermissionsStddevFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePlanPermissionsStddevPopFields = <
  T extends PlanPermissionsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePlanPermissionsStddevSampFields = <
  T extends PlanPermissionsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePlanPermissionsSumFields = <
  T extends PlanPermissionsSumFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePlanPermissionsVarPopFields = <
  T extends PlanPermissionsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePlanPermissionsVarSampFields = <
  T extends PlanPermissionsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includePlanPermissionsVarianceFields = <
  T extends PlanPermissionsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface QueryRootSelection {
  ad_daily_metrics?: boolean | boolean;
  ad_daily_metrics_aggregate?: boolean | boolean;
  ad_daily_metrics_by_pk?:
    | boolean
    | {
        select?: AdDailyMetricsSelection;
        include?: AdDailyMetricsSelection;
      };
  ad_packages?: boolean | boolean;
  ad_packages_aggregate?: boolean | boolean;
  ad_packages_by_pk?:
    | boolean
    | {
        select?: AdPackagesSelection;
        include?: AdPackagesSelection;
      };
  ad_variants?: boolean | boolean;
  ad_variants_aggregate?: boolean | boolean;
  ad_variants_by_pk?:
    | boolean
    | {
        select?: AdVariantsSelection;
        include?: AdVariantsSelection;
      };
  addresses?: boolean | boolean;
  addresses_aggregate?: boolean | boolean;
  addresses_by_pk?:
    | boolean
    | {
        select?: AddressesSelection;
        include?: AddressesSelection;
      };
  ads?: boolean | boolean;
  ads_aggregate?: boolean | boolean;
  ads_by_pk?:
    | boolean
    | {
        select?: AdsSelection;
        include?: AdsSelection;
      };
  blacklisted_domains?: boolean | boolean;
  blacklisted_domains_aggregate?: boolean | boolean;
  blacklisted_domains_by_pk?:
    | boolean
    | {
        select?: BlacklistedDomainsSelection;
        include?: BlacklistedDomainsSelection;
      };
  blacklisted_urls?: boolean | boolean;
  blacklisted_urls_aggregate?: boolean | boolean;
  blacklisted_urls_by_pk?:
    | boolean
    | {
        select?: BlacklistedUrlsSelection;
        include?: BlacklistedUrlsSelection;
      };
  blocked_ips?: boolean | boolean;
  blocked_ips_aggregate?: boolean | boolean;
  blocked_ips_by_pk?:
    | boolean
    | {
        select?: BlockedIpsSelection;
        include?: BlockedIpsSelection;
      };
  bookmark_folders?: boolean | boolean;
  bookmark_folders_aggregate?: boolean | boolean;
  bookmark_folders_by_pk?:
    | boolean
    | {
        select?: BookmarkFoldersSelection;
        include?: BookmarkFoldersSelection;
      };
  bookmarks?: boolean | boolean;
  bookmarks_aggregate?: boolean | boolean;
  bookmarks_by_pk?:
    | boolean
    | {
        select?: BookmarksSelection;
        include?: BookmarksSelection;
      };
  business_domains?: boolean | boolean;
  business_domains_aggregate?: boolean | boolean;
  business_domains_by_pk?:
    | boolean
    | {
        select?: BusinessDomainsSelection;
        include?: BusinessDomainsSelection;
      };
  categories?: boolean | boolean;
  categories_aggregate?: boolean | boolean;
  categories_by_pk?:
    | boolean
    | {
        select?: CategoriesSelection;
        include?: CategoriesSelection;
      };
  categorized_urls?: boolean | boolean;
  categorized_urls_aggregate?: boolean | boolean;
  categorized_urls_by_pk?:
    | boolean
    | {
        select?: CategorizedUrlsSelection;
        include?: CategorizedUrlsSelection;
      };
  circuit_breaker_states?: boolean | boolean;
  circuit_breaker_states_aggregate?: boolean | boolean;
  circuit_breaker_states_by_pk?:
    | boolean
    | {
        select?: CircuitBreakerStatesSelection;
        include?: CircuitBreakerStatesSelection;
      };
  cities?: boolean | boolean;
  cities_aggregate?: boolean | boolean;
  cities_by_pk?:
    | boolean
    | {
        select?: CitiesSelection;
        include?: CitiesSelection;
      };
  comments?: boolean | boolean;
  comments_aggregate?: boolean | boolean;
  comments_by_pk?:
    | boolean
    | {
        select?: CommentsSelection;
        include?: CommentsSelection;
      };
  companies?: boolean | boolean;
  companies_aggregate?: boolean | boolean;
  companies_by_pk?:
    | boolean
    | {
        select?: CompaniesSelection;
        include?: CompaniesSelection;
      };
  company_contacts?: boolean | boolean;
  company_contacts_aggregate?: boolean | boolean;
  company_contacts_by_pk?:
    | boolean
    | {
        select?: CompanyContactsSelection;
        include?: CompanyContactsSelection;
      };
  company_employees?: boolean | boolean;
  company_employees_aggregate?: boolean | boolean;
  company_employees_by_pk?:
    | boolean
    | {
        select?: CompanyEmployeesSelection;
        include?: CompanyEmployeesSelection;
      };
  company_extras?: boolean | boolean;
  company_extras_aggregate?: boolean | boolean;
  company_extras_by_pk?:
    | boolean
    | {
        select?: CompanyExtrasSelection;
        include?: CompanyExtrasSelection;
      };
  company_metrics?: boolean | boolean;
  company_metrics_aggregate?: boolean | boolean;
  company_metrics_by_pk?:
    | boolean
    | {
        select?: CompanyMetricsSelection;
        include?: CompanyMetricsSelection;
      };
  contacts?: boolean | boolean;
  contacts_aggregate?: boolean | boolean;
  contacts_by_pk?:
    | boolean
    | {
        select?: ContactsSelection;
        include?: ContactsSelection;
      };
  content_categories?: boolean | boolean;
  content_categories_aggregate?: boolean | boolean;
  content_categories_by_pk?:
    | boolean
    | {
        select?: ContentCategoriesSelection;
        include?: ContentCategoriesSelection;
      };
  content_scores?: boolean | boolean;
  content_scores_aggregate?: boolean | boolean;
  content_source_visits?: boolean | boolean;
  content_source_visits_aggregate?: boolean | boolean;
  content_source_visits_by_pk?:
    | boolean
    | {
        select?: ContentSourceVisitsSelection;
        include?: ContentSourceVisitsSelection;
      };
  content_sources?: boolean | boolean;
  content_sources_aggregate?: boolean | boolean;
  content_sources_by_pk?:
    | boolean
    | {
        select?: ContentSourcesSelection;
        include?: ContentSourcesSelection;
      };
  content_statuses?: boolean | boolean;
  content_statuses_aggregate?: boolean | boolean;
  content_statuses_by_pk?:
    | boolean
    | {
        select?: ContentStatusesSelection;
        include?: ContentStatusesSelection;
      };
  content_tags?: boolean | boolean;
  content_tags_aggregate?: boolean | boolean;
  content_tags_by_pk?:
    | boolean
    | {
        select?: ContentTagsSelection;
        include?: ContentTagsSelection;
      };
  contents?: boolean | boolean;
  contents_aggregate?: boolean | boolean;
  contents_by_pk?:
    | boolean
    | {
        select?: ContentsSelection;
        include?: ContentsSelection;
      };
  countries?: boolean | boolean;
  countries_aggregate?: boolean | boolean;
  countries_by_pk?:
    | boolean
    | {
        select?: CountriesSelection;
        include?: CountriesSelection;
      };
  customer_payments?: boolean | boolean;
  customer_payments_aggregate?: boolean | boolean;
  customer_payments_by_pk?:
    | boolean
    | {
        select?: CustomerPaymentsSelection;
        include?: CustomerPaymentsSelection;
      };
  customer_processed_webhooks?: boolean | boolean;
  customer_processed_webhooks_aggregate?: boolean | boolean;
  customer_processed_webhooks_by_pk?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksSelection;
        include?: CustomerProcessedWebhooksSelection;
      };
  customer_refunds?: boolean | boolean;
  customer_refunds_aggregate?: boolean | boolean;
  customer_refunds_by_pk?:
    | boolean
    | {
        select?: CustomerRefundsSelection;
        include?: CustomerRefundsSelection;
      };
  customer_subscription_plans?: boolean | boolean;
  customer_subscription_plans_aggregate?: boolean | boolean;
  customer_subscription_plans_by_pk?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansSelection;
        include?: CustomerSubscriptionPlansSelection;
      };
  customer_subscriptions?: boolean | boolean;
  customer_subscriptions_aggregate?: boolean | boolean;
  customer_subscriptions_by_pk?:
    | boolean
    | {
        select?: CustomerSubscriptionsSelection;
        include?: CustomerSubscriptionsSelection;
      };
  embedding_reviews?: boolean | boolean;
  embedding_reviews_aggregate?: boolean | boolean;
  embedding_reviews_by_pk?:
    | boolean
    | {
        select?: EmbeddingReviewsSelection;
        include?: EmbeddingReviewsSelection;
      };
  error_correlations?: boolean | boolean;
  error_correlations_aggregate?: boolean | boolean;
  error_frequency?: boolean | boolean;
  error_frequency_aggregate?: boolean | boolean;
  error_logs?: boolean | boolean;
  error_logs_aggregate?: boolean | boolean;
  error_logs_by_pk?:
    | boolean
    | {
        select?: ErrorLogsSelection;
        include?: ErrorLogsSelection;
      };
  error_metrics?: boolean | boolean;
  error_metrics_aggregate?: boolean | boolean;
  error_patterns?: boolean | boolean;
  error_patterns_aggregate?: boolean | boolean;
  error_stats?: boolean | boolean;
  error_stats_aggregate?: boolean | boolean;
  feature_requests?: boolean | boolean;
  feature_requests_aggregate?: boolean | boolean;
  feature_requests_by_pk?:
    | boolean
    | {
        select?: FeatureRequestsSelection;
        include?: FeatureRequestsSelection;
      };
  feature_votes?: boolean | boolean;
  feature_votes_aggregate?: boolean | boolean;
  feature_votes_by_pk?:
    | boolean
    | {
        select?: FeatureVotesSelection;
        include?: FeatureVotesSelection;
      };
  feed_categories?: boolean | boolean;
  feed_categories_aggregate?: boolean | boolean;
  feed_categories_by_pk?:
    | boolean
    | {
        select?: FeedCategoriesSelection;
        include?: FeedCategoriesSelection;
      };
  feed_sources?: boolean | boolean;
  feed_sources_aggregate?: boolean | boolean;
  feed_sources_by_pk?:
    | boolean
    | {
        select?: FeedSourcesSelection;
        include?: FeedSourcesSelection;
      };
  feedbacks?: boolean | boolean;
  feedbacks_aggregate?: boolean | boolean;
  feedbacks_by_pk?:
    | boolean
    | {
        select?: FeedbacksSelection;
        include?: FeedbacksSelection;
      };
  feeds?: boolean | boolean;
  feeds_aggregate?: boolean | boolean;
  feeds_by_pk?:
    | boolean
    | {
        select?: FeedsSelection;
        include?: FeedsSelection;
      };
  follows?: boolean | boolean;
  follows_aggregate?: boolean | boolean;
  follows_by_pk?:
    | boolean
    | {
        select?: FollowsSelection;
        include?: FollowsSelection;
      };
  metric_definitions?: boolean | boolean;
  metric_definitions_aggregate?: boolean | boolean;
  metric_definitions_by_pk?:
    | boolean
    | {
        select?: MetricDefinitionsSelection;
        include?: MetricDefinitionsSelection;
      };
  news?: boolean | boolean;
  news_aggregate?: boolean | boolean;
  news_by_pk?:
    | boolean
    | {
        select?: NewsSelection;
        include?: NewsSelection;
      };
  news_details?: boolean | boolean;
  news_details_aggregate?: boolean | boolean;
  news_summaries?: boolean | boolean;
  news_summaries_aggregate?: boolean | boolean;
  news_summaries_by_pk?:
    | boolean
    | {
        select?: NewsSummariesSelection;
        include?: NewsSummariesSelection;
      };
  news_tags?: boolean | boolean;
  news_tags_aggregate?: boolean | boolean;
  news_tags_by_pk?:
    | boolean
    | {
        select?: NewsTagsSelection;
        include?: NewsTagsSelection;
      };
  newsletters?: boolean | boolean;
  newsletters_aggregate?: boolean | boolean;
  newsletters_by_pk?:
    | boolean
    | {
        select?: NewslettersSelection;
        include?: NewslettersSelection;
      };
  payment_providers?: boolean | boolean;
  payment_providers_aggregate?: boolean | boolean;
  payment_providers_by_pk?:
    | boolean
    | {
        select?: PaymentProvidersSelection;
        include?: PaymentProvidersSelection;
      };
  plan_permissions?: boolean | boolean;
  plan_permissions_aggregate?: boolean | boolean;
  plan_permissions_by_pk?:
    | boolean
    | {
        select?: PlanPermissionsSelection;
        include?: PlanPermissionsSelection;
      };
  recent_errors?: boolean | boolean;
  recent_errors_aggregate?: boolean | boolean;
  referral_stats?: boolean | boolean;
  referral_stats_aggregate?: boolean | boolean;
  referrals?: boolean | boolean;
  referrals_aggregate?: boolean | boolean;
  referrals_by_pk?:
    | boolean
    | {
        select?: ReferralsSelection;
        include?: ReferralsSelection;
      };
  referrer_blocks?: boolean | boolean;
  referrer_blocks_aggregate?: boolean | boolean;
  referrer_blocks_by_pk?:
    | boolean
    | {
        select?: ReferrerBlocksSelection;
        include?: ReferrerBlocksSelection;
      };
  referrer_risk_metrics?: boolean | boolean;
  referrer_risk_metrics_aggregate?: boolean | boolean;
  research?: boolean | boolean;
  research_aggregate?: boolean | boolean;
  research_by_pk?:
    | boolean
    | {
        select?: ResearchSelection;
        include?: ResearchSelection;
      };
  research_embeddings?: boolean | boolean;
  research_embeddings_aggregate?: boolean | boolean;
  research_embeddings_by_pk?:
    | boolean
    | {
        select?: ResearchEmbeddingsSelection;
        include?: ResearchEmbeddingsSelection;
      };
  responses?: boolean | boolean;
  responses_aggregate?: boolean | boolean;
  responses_by_pk?:
    | boolean
    | {
        select?: ResponsesSelection;
        include?: ResponsesSelection;
      };
  role_hierarchy?: boolean | boolean;
  role_hierarchy_aggregate?: boolean | boolean;
  role_hierarchy_by_pk?:
    | boolean
    | {
        select?: RoleHierarchySelection;
        include?: RoleHierarchySelection;
      };
  role_permissions?: boolean | boolean;
  role_permissions_aggregate?: boolean | boolean;
  role_permissions_by_pk?:
    | boolean
    | {
        select?: RolePermissionsSelection;
        include?: RolePermissionsSelection;
      };
  role_permissions_materialized?: boolean | boolean;
  role_permissions_materialized_aggregate?: boolean | boolean;
  role_permissions_materialized_by_pk?:
    | boolean
    | {
        select?: RolePermissionsMaterializedSelection;
        include?: RolePermissionsMaterializedSelection;
      };
  scoring_weights?: boolean | boolean;
  scoring_weights_aggregate?: boolean | boolean;
  scoring_weights_by_pk?:
    | boolean
    | {
        select?: ScoringWeightsSelection;
        include?: ScoringWeightsSelection;
      };
  searches?: boolean | boolean;
  searches_aggregate?: boolean | boolean;
  searches_by_pk?:
    | boolean
    | {
        select?: SearchesSelection;
        include?: SearchesSelection;
      };
  security_metrics?: boolean | boolean;
  security_metrics_aggregate?: boolean | boolean;
  slow_query_patterns?: boolean | boolean;
  slow_query_patterns_aggregate?: boolean | boolean;
  social_media?: boolean | boolean;
  social_media_aggregate?: boolean | boolean;
  social_media_by_pk?:
    | boolean
    | {
        select?: SocialMediaSelection;
        include?: SocialMediaSelection;
      };
  spider_metrics?: boolean | boolean;
  spider_metrics_aggregate?: boolean | boolean;
  spider_metrics_by_pk?:
    | boolean
    | {
        select?: SpiderMetricsSelection;
        include?: SpiderMetricsSelection;
      };
  strapi_migrations?: boolean | boolean;
  strapi_migrations_aggregate?: boolean | boolean;
  strapi_migrations_by_pk?:
    | boolean
    | {
        select?: StrapiMigrationsSelection;
        include?: StrapiMigrationsSelection;
      };
  strapi_migrations_internal?: boolean | boolean;
  strapi_migrations_internal_aggregate?: boolean | boolean;
  strapi_migrations_internal_by_pk?:
    | boolean
    | {
        select?: StrapiMigrationsInternalSelection;
        include?: StrapiMigrationsInternalSelection;
      };
  table_maintenance_log?: boolean | boolean;
  table_maintenance_log_aggregate?: boolean | boolean;
  table_maintenance_log_by_pk?:
    | boolean
    | {
        select?: TableMaintenanceLogSelection;
        include?: TableMaintenanceLogSelection;
      };
  table_query_performance?: boolean | boolean;
  table_query_performance_aggregate?: boolean | boolean;
  table_sequence_usage?: boolean | boolean;
  table_sequence_usage_aggregate?: boolean | boolean;
  table_statistics?: boolean | boolean;
  table_statistics_aggregate?: boolean | boolean;
  table_statistics_by_pk?:
    | boolean
    | {
        select?: TableStatisticsSelection;
        include?: TableStatisticsSelection;
      };
  tags?: boolean | boolean;
  tags_aggregate?: boolean | boolean;
  tags_by_pk?:
    | boolean
    | {
        select?: TagsSelection;
        include?: TagsSelection;
      };
  user_metrics?: boolean | boolean;
  user_metrics_aggregate?: boolean | boolean;
  user_metrics_by_pk?:
    | boolean
    | {
        select?: UserMetricsSelection;
        include?: UserMetricsSelection;
      };
  user_profiles?: boolean | boolean;
  user_profiles_aggregate?: boolean | boolean;
  user_profiles_by_pk?:
    | boolean
    | {
        select?: UserProfilesSelection;
        include?: UserProfilesSelection;
      };
  votes?: boolean | boolean;
  votes_aggregate?: boolean | boolean;
  votes_by_pk?:
    | boolean
    | {
        select?: VotesSelection;
        include?: VotesSelection;
      };
  workflows?: boolean | boolean;
  workflows_aggregate?: boolean | boolean;
  workflows_by_pk?:
    | boolean
    | {
        select?: WorkflowsSelection;
        include?: WorkflowsSelection;
      };
}

export const includeQueryRoot = <T extends QueryRootSelection>(include: T) =>
  include;

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

export interface RecentErrorsSelection {
  created_at?: boolean | boolean;
  error_type?: boolean | boolean;
  message?: boolean | boolean;
  metadata?: boolean | boolean;
  service_name?: boolean | boolean;
  severity?: boolean | boolean;
}

export const includeRecentErrors = <T extends RecentErrorsSelection>(
  include: T,
) => include;

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

export interface RecentErrorsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: RecentErrorsAggregateFieldsSelection;
        include?: RecentErrorsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeRecentErrorsAggregate = <
  T extends RecentErrorsAggregateSelection,
>(
  include: T,
) => include;

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

export interface RecentErrorsAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: RecentErrorsMaxFieldsSelection;
        include?: RecentErrorsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: RecentErrorsMinFieldsSelection;
        include?: RecentErrorsMinFieldsSelection;
      };
}

export const includeRecentErrorsAggregateFields = <
  T extends RecentErrorsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface RecentErrorsMaxFieldsSelection {
  created_at?: boolean | boolean;
  error_type?: boolean | boolean;
  message?: boolean | boolean;
  service_name?: boolean | boolean;
  severity?: boolean | boolean;
}

export const includeRecentErrorsMaxFields = <
  T extends RecentErrorsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface RecentErrorsMinFieldsSelection {
  created_at?: boolean | boolean;
  error_type?: boolean | boolean;
  message?: boolean | boolean;
  service_name?: boolean | boolean;
  severity?: boolean | boolean;
}

export const includeRecentErrorsMinFields = <
  T extends RecentErrorsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeRecentErrorsMutationResponse = <
  T extends RecentErrorsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface ReferralStatsSelection {
  active_days?: boolean | boolean;
  avg_conversion_time_hours?: boolean | boolean;
  conversion_rate?: boolean | boolean;
  conversions?: boolean | boolean;
  referrer_code?: boolean | boolean;
  total_referrals?: boolean | boolean;
  total_value?: boolean | boolean;
  unique_visitors?: boolean | boolean;
}

export const includeReferralStats = <T extends ReferralStatsSelection>(
  include: T,
) => include;

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

export interface ReferralStatsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ReferralStatsAggregateFieldsSelection;
        include?: ReferralStatsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeReferralStatsAggregate = <
  T extends ReferralStatsAggregateSelection,
>(
  include: T,
) => include;

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

export interface ReferralStatsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ReferralStatsAvgFieldsSelection;
        include?: ReferralStatsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ReferralStatsMaxFieldsSelection;
        include?: ReferralStatsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ReferralStatsMinFieldsSelection;
        include?: ReferralStatsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ReferralStatsStddevFieldsSelection;
        include?: ReferralStatsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ReferralStatsStddevPopFieldsSelection;
        include?: ReferralStatsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ReferralStatsStddevSampFieldsSelection;
        include?: ReferralStatsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ReferralStatsSumFieldsSelection;
        include?: ReferralStatsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ReferralStatsVarPopFieldsSelection;
        include?: ReferralStatsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ReferralStatsVarSampFieldsSelection;
        include?: ReferralStatsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ReferralStatsVarianceFieldsSelection;
        include?: ReferralStatsVarianceFieldsSelection;
      };
}

export const includeReferralStatsAggregateFields = <
  T extends ReferralStatsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralStatsAvgFieldsSelection {
  active_days?: boolean | boolean;
  avg_conversion_time_hours?: boolean | boolean;
  conversion_rate?: boolean | boolean;
  conversions?: boolean | boolean;
  total_referrals?: boolean | boolean;
  total_value?: boolean | boolean;
  unique_visitors?: boolean | boolean;
}

export const includeReferralStatsAvgFields = <
  T extends ReferralStatsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralStatsMaxFieldsSelection {
  active_days?: boolean | boolean;
  avg_conversion_time_hours?: boolean | boolean;
  conversion_rate?: boolean | boolean;
  conversions?: boolean | boolean;
  referrer_code?: boolean | boolean;
  total_referrals?: boolean | boolean;
  total_value?: boolean | boolean;
  unique_visitors?: boolean | boolean;
}

export const includeReferralStatsMaxFields = <
  T extends ReferralStatsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralStatsMinFieldsSelection {
  active_days?: boolean | boolean;
  avg_conversion_time_hours?: boolean | boolean;
  conversion_rate?: boolean | boolean;
  conversions?: boolean | boolean;
  referrer_code?: boolean | boolean;
  total_referrals?: boolean | boolean;
  total_value?: boolean | boolean;
  unique_visitors?: boolean | boolean;
}

export const includeReferralStatsMinFields = <
  T extends ReferralStatsMinFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralStatsStddevFieldsSelection {
  active_days?: boolean | boolean;
  avg_conversion_time_hours?: boolean | boolean;
  conversion_rate?: boolean | boolean;
  conversions?: boolean | boolean;
  total_referrals?: boolean | boolean;
  total_value?: boolean | boolean;
  unique_visitors?: boolean | boolean;
}

export const includeReferralStatsStddevFields = <
  T extends ReferralStatsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralStatsStddevPopFieldsSelection {
  active_days?: boolean | boolean;
  avg_conversion_time_hours?: boolean | boolean;
  conversion_rate?: boolean | boolean;
  conversions?: boolean | boolean;
  total_referrals?: boolean | boolean;
  total_value?: boolean | boolean;
  unique_visitors?: boolean | boolean;
}

export const includeReferralStatsStddevPopFields = <
  T extends ReferralStatsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralStatsStddevSampFieldsSelection {
  active_days?: boolean | boolean;
  avg_conversion_time_hours?: boolean | boolean;
  conversion_rate?: boolean | boolean;
  conversions?: boolean | boolean;
  total_referrals?: boolean | boolean;
  total_value?: boolean | boolean;
  unique_visitors?: boolean | boolean;
}

export const includeReferralStatsStddevSampFields = <
  T extends ReferralStatsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralStatsSumFieldsSelection {
  active_days?: boolean | boolean;
  avg_conversion_time_hours?: boolean | boolean;
  conversion_rate?: boolean | boolean;
  conversions?: boolean | boolean;
  total_referrals?: boolean | boolean;
  total_value?: boolean | boolean;
  unique_visitors?: boolean | boolean;
}

export const includeReferralStatsSumFields = <
  T extends ReferralStatsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralStatsVarPopFieldsSelection {
  active_days?: boolean | boolean;
  avg_conversion_time_hours?: boolean | boolean;
  conversion_rate?: boolean | boolean;
  conversions?: boolean | boolean;
  total_referrals?: boolean | boolean;
  total_value?: boolean | boolean;
  unique_visitors?: boolean | boolean;
}

export const includeReferralStatsVarPopFields = <
  T extends ReferralStatsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralStatsVarSampFieldsSelection {
  active_days?: boolean | boolean;
  avg_conversion_time_hours?: boolean | boolean;
  conversion_rate?: boolean | boolean;
  conversions?: boolean | boolean;
  total_referrals?: boolean | boolean;
  total_value?: boolean | boolean;
  unique_visitors?: boolean | boolean;
}

export const includeReferralStatsVarSampFields = <
  T extends ReferralStatsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralStatsVarianceFieldsSelection {
  active_days?: boolean | boolean;
  avg_conversion_time_hours?: boolean | boolean;
  conversion_rate?: boolean | boolean;
  conversions?: boolean | boolean;
  total_referrals?: boolean | boolean;
  total_value?: boolean | boolean;
  unique_visitors?: boolean | boolean;
}

export const includeReferralStatsVarianceFields = <
  T extends ReferralStatsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralsSelection {
  browser?: boolean | boolean;
  client_fingerprint?: boolean | boolean;
  conversion_value?: boolean | boolean;
  converted_at?: boolean | boolean;
  country_code?: boolean | boolean;
  created_at?: boolean | boolean;
  device_type?: boolean | boolean;
  id?: boolean | boolean;
  ip_address?: boolean | boolean;
  is_suspicious?: boolean | boolean;
  landing_page?: boolean | boolean;
  last_failed_attempt?: boolean | boolean;
  referral_status?: boolean | boolean;
  referrer_code?: boolean | boolean;
  region?: boolean | boolean;
  security_flags?: boolean | boolean;
  user_agent?: boolean | boolean;
  utm_campaign?: boolean | boolean;
  utm_medium?: boolean | boolean;
  utm_source?: boolean | boolean;
  validation_attempts?: boolean | boolean;
  visitor_id?: boolean | boolean;
}

export const includeReferrals = <T extends ReferralsSelection>(include: T) =>
  include;

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

export interface ReferralsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ReferralsAggregateFieldsSelection;
        include?: ReferralsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeReferralsAggregate = <
  T extends ReferralsAggregateSelection,
>(
  include: T,
) => include;

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

export interface ReferralsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ReferralsAvgFieldsSelection;
        include?: ReferralsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ReferralsMaxFieldsSelection;
        include?: ReferralsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ReferralsMinFieldsSelection;
        include?: ReferralsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ReferralsStddevFieldsSelection;
        include?: ReferralsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ReferralsStddevPopFieldsSelection;
        include?: ReferralsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ReferralsStddevSampFieldsSelection;
        include?: ReferralsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ReferralsSumFieldsSelection;
        include?: ReferralsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ReferralsVarPopFieldsSelection;
        include?: ReferralsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ReferralsVarSampFieldsSelection;
        include?: ReferralsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ReferralsVarianceFieldsSelection;
        include?: ReferralsVarianceFieldsSelection;
      };
}

export const includeReferralsAggregateFields = <
  T extends ReferralsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralsAvgFieldsSelection {
  conversion_value?: boolean | boolean;
  validation_attempts?: boolean | boolean;
}

export const includeReferralsAvgFields = <
  T extends ReferralsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralsMaxFieldsSelection {
  browser?: boolean | boolean;
  client_fingerprint?: boolean | boolean;
  conversion_value?: boolean | boolean;
  converted_at?: boolean | boolean;
  country_code?: boolean | boolean;
  created_at?: boolean | boolean;
  device_type?: boolean | boolean;
  id?: boolean | boolean;
  landing_page?: boolean | boolean;
  last_failed_attempt?: boolean | boolean;
  referral_status?: boolean | boolean;
  referrer_code?: boolean | boolean;
  region?: boolean | boolean;
  user_agent?: boolean | boolean;
  utm_campaign?: boolean | boolean;
  utm_medium?: boolean | boolean;
  utm_source?: boolean | boolean;
  validation_attempts?: boolean | boolean;
  visitor_id?: boolean | boolean;
}

export const includeReferralsMaxFields = <
  T extends ReferralsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralsMinFieldsSelection {
  browser?: boolean | boolean;
  client_fingerprint?: boolean | boolean;
  conversion_value?: boolean | boolean;
  converted_at?: boolean | boolean;
  country_code?: boolean | boolean;
  created_at?: boolean | boolean;
  device_type?: boolean | boolean;
  id?: boolean | boolean;
  landing_page?: boolean | boolean;
  last_failed_attempt?: boolean | boolean;
  referral_status?: boolean | boolean;
  referrer_code?: boolean | boolean;
  region?: boolean | boolean;
  user_agent?: boolean | boolean;
  utm_campaign?: boolean | boolean;
  utm_medium?: boolean | boolean;
  utm_source?: boolean | boolean;
  validation_attempts?: boolean | boolean;
  visitor_id?: boolean | boolean;
}

export const includeReferralsMinFields = <
  T extends ReferralsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeReferralsMutationResponse = <
  T extends ReferralsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface ReferralsStddevFieldsSelection {
  conversion_value?: boolean | boolean;
  validation_attempts?: boolean | boolean;
}

export const includeReferralsStddevFields = <
  T extends ReferralsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralsStddevPopFieldsSelection {
  conversion_value?: boolean | boolean;
  validation_attempts?: boolean | boolean;
}

export const includeReferralsStddevPopFields = <
  T extends ReferralsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralsStddevSampFieldsSelection {
  conversion_value?: boolean | boolean;
  validation_attempts?: boolean | boolean;
}

export const includeReferralsStddevSampFields = <
  T extends ReferralsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralsSumFieldsSelection {
  conversion_value?: boolean | boolean;
  validation_attempts?: boolean | boolean;
}

export const includeReferralsSumFields = <
  T extends ReferralsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralsVarPopFieldsSelection {
  conversion_value?: boolean | boolean;
  validation_attempts?: boolean | boolean;
}

export const includeReferralsVarPopFields = <
  T extends ReferralsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralsVarSampFieldsSelection {
  conversion_value?: boolean | boolean;
  validation_attempts?: boolean | boolean;
}

export const includeReferralsVarSampFields = <
  T extends ReferralsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferralsVarianceFieldsSelection {
  conversion_value?: boolean | boolean;
  validation_attempts?: boolean | boolean;
}

export const includeReferralsVarianceFields = <
  T extends ReferralsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferrerBlocksSelection {
  blocked_at?: boolean | boolean;
  blocked_by?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  is_permanent?: boolean | boolean;
  reason?: boolean | boolean;
  referrer_code?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeReferrerBlocks = <T extends ReferrerBlocksSelection>(
  include: T,
) => include;

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

export interface ReferrerBlocksAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ReferrerBlocksAggregateFieldsSelection;
        include?: ReferrerBlocksAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeReferrerBlocksAggregate = <
  T extends ReferrerBlocksAggregateSelection,
>(
  include: T,
) => include;

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

export interface ReferrerBlocksAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ReferrerBlocksMaxFieldsSelection;
        include?: ReferrerBlocksMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ReferrerBlocksMinFieldsSelection;
        include?: ReferrerBlocksMinFieldsSelection;
      };
}

export const includeReferrerBlocksAggregateFields = <
  T extends ReferrerBlocksAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferrerBlocksMaxFieldsSelection {
  blocked_at?: boolean | boolean;
  blocked_by?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  reason?: boolean | boolean;
  referrer_code?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeReferrerBlocksMaxFields = <
  T extends ReferrerBlocksMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferrerBlocksMinFieldsSelection {
  blocked_at?: boolean | boolean;
  blocked_by?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  reason?: boolean | boolean;
  referrer_code?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeReferrerBlocksMinFields = <
  T extends ReferrerBlocksMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeReferrerBlocksMutationResponse = <
  T extends ReferrerBlocksMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface ReferrerRiskMetricsSelection {
  active_days?: boolean | boolean;
  high_attempt_instances?: boolean | boolean;
  max_validation_attempts?: boolean | boolean;
  referrer_code?: boolean | boolean;
  suspicious_count?: boolean | boolean;
  suspicious_percentage?: boolean | boolean;
  total_referrals?: boolean | boolean;
  unique_ips?: boolean | boolean;
}

export const includeReferrerRiskMetrics = <
  T extends ReferrerRiskMetricsSelection,
>(
  include: T,
) => include;

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

export interface ReferrerRiskMetricsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ReferrerRiskMetricsAggregateFieldsSelection;
        include?: ReferrerRiskMetricsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeReferrerRiskMetricsAggregate = <
  T extends ReferrerRiskMetricsAggregateSelection,
>(
  include: T,
) => include;

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

export interface ReferrerRiskMetricsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ReferrerRiskMetricsAvgFieldsSelection;
        include?: ReferrerRiskMetricsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ReferrerRiskMetricsMaxFieldsSelection;
        include?: ReferrerRiskMetricsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ReferrerRiskMetricsMinFieldsSelection;
        include?: ReferrerRiskMetricsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ReferrerRiskMetricsStddevFieldsSelection;
        include?: ReferrerRiskMetricsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ReferrerRiskMetricsStddevPopFieldsSelection;
        include?: ReferrerRiskMetricsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ReferrerRiskMetricsStddevSampFieldsSelection;
        include?: ReferrerRiskMetricsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ReferrerRiskMetricsSumFieldsSelection;
        include?: ReferrerRiskMetricsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ReferrerRiskMetricsVarPopFieldsSelection;
        include?: ReferrerRiskMetricsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ReferrerRiskMetricsVarSampFieldsSelection;
        include?: ReferrerRiskMetricsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ReferrerRiskMetricsVarianceFieldsSelection;
        include?: ReferrerRiskMetricsVarianceFieldsSelection;
      };
}

export const includeReferrerRiskMetricsAggregateFields = <
  T extends ReferrerRiskMetricsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferrerRiskMetricsAvgFieldsSelection {
  active_days?: boolean | boolean;
  high_attempt_instances?: boolean | boolean;
  max_validation_attempts?: boolean | boolean;
  suspicious_count?: boolean | boolean;
  suspicious_percentage?: boolean | boolean;
  total_referrals?: boolean | boolean;
  unique_ips?: boolean | boolean;
}

export const includeReferrerRiskMetricsAvgFields = <
  T extends ReferrerRiskMetricsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferrerRiskMetricsMaxFieldsSelection {
  active_days?: boolean | boolean;
  high_attempt_instances?: boolean | boolean;
  max_validation_attempts?: boolean | boolean;
  referrer_code?: boolean | boolean;
  suspicious_count?: boolean | boolean;
  suspicious_percentage?: boolean | boolean;
  total_referrals?: boolean | boolean;
  unique_ips?: boolean | boolean;
}

export const includeReferrerRiskMetricsMaxFields = <
  T extends ReferrerRiskMetricsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferrerRiskMetricsMinFieldsSelection {
  active_days?: boolean | boolean;
  high_attempt_instances?: boolean | boolean;
  max_validation_attempts?: boolean | boolean;
  referrer_code?: boolean | boolean;
  suspicious_count?: boolean | boolean;
  suspicious_percentage?: boolean | boolean;
  total_referrals?: boolean | boolean;
  unique_ips?: boolean | boolean;
}

export const includeReferrerRiskMetricsMinFields = <
  T extends ReferrerRiskMetricsMinFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferrerRiskMetricsStddevFieldsSelection {
  active_days?: boolean | boolean;
  high_attempt_instances?: boolean | boolean;
  max_validation_attempts?: boolean | boolean;
  suspicious_count?: boolean | boolean;
  suspicious_percentage?: boolean | boolean;
  total_referrals?: boolean | boolean;
  unique_ips?: boolean | boolean;
}

export const includeReferrerRiskMetricsStddevFields = <
  T extends ReferrerRiskMetricsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferrerRiskMetricsStddevPopFieldsSelection {
  active_days?: boolean | boolean;
  high_attempt_instances?: boolean | boolean;
  max_validation_attempts?: boolean | boolean;
  suspicious_count?: boolean | boolean;
  suspicious_percentage?: boolean | boolean;
  total_referrals?: boolean | boolean;
  unique_ips?: boolean | boolean;
}

export const includeReferrerRiskMetricsStddevPopFields = <
  T extends ReferrerRiskMetricsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferrerRiskMetricsStddevSampFieldsSelection {
  active_days?: boolean | boolean;
  high_attempt_instances?: boolean | boolean;
  max_validation_attempts?: boolean | boolean;
  suspicious_count?: boolean | boolean;
  suspicious_percentage?: boolean | boolean;
  total_referrals?: boolean | boolean;
  unique_ips?: boolean | boolean;
}

export const includeReferrerRiskMetricsStddevSampFields = <
  T extends ReferrerRiskMetricsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferrerRiskMetricsSumFieldsSelection {
  active_days?: boolean | boolean;
  high_attempt_instances?: boolean | boolean;
  max_validation_attempts?: boolean | boolean;
  suspicious_count?: boolean | boolean;
  suspicious_percentage?: boolean | boolean;
  total_referrals?: boolean | boolean;
  unique_ips?: boolean | boolean;
}

export const includeReferrerRiskMetricsSumFields = <
  T extends ReferrerRiskMetricsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferrerRiskMetricsVarPopFieldsSelection {
  active_days?: boolean | boolean;
  high_attempt_instances?: boolean | boolean;
  max_validation_attempts?: boolean | boolean;
  suspicious_count?: boolean | boolean;
  suspicious_percentage?: boolean | boolean;
  total_referrals?: boolean | boolean;
  unique_ips?: boolean | boolean;
}

export const includeReferrerRiskMetricsVarPopFields = <
  T extends ReferrerRiskMetricsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferrerRiskMetricsVarSampFieldsSelection {
  active_days?: boolean | boolean;
  high_attempt_instances?: boolean | boolean;
  max_validation_attempts?: boolean | boolean;
  suspicious_count?: boolean | boolean;
  suspicious_percentage?: boolean | boolean;
  total_referrals?: boolean | boolean;
  unique_ips?: boolean | boolean;
}

export const includeReferrerRiskMetricsVarSampFields = <
  T extends ReferrerRiskMetricsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ReferrerRiskMetricsVarianceFieldsSelection {
  active_days?: boolean | boolean;
  high_attempt_instances?: boolean | boolean;
  max_validation_attempts?: boolean | boolean;
  suspicious_count?: boolean | boolean;
  suspicious_percentage?: boolean | boolean;
  total_referrals?: boolean | boolean;
  unique_ips?: boolean | boolean;
}

export const includeReferrerRiskMetricsVarianceFields = <
  T extends ReferrerRiskMetricsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchSelection {
  abstract?: boolean | boolean;
  abstract_url?: boolean | boolean;
  affiliations?: boolean | boolean;
  authors?: boolean | boolean;
  category?: boolean | boolean;
  comments?: boolean | boolean;
  content?: boolean | boolean;
  content_status?: boolean | boolean;
  created_at?: boolean | boolean;
  doi_url?: boolean | boolean;
  figure_count?: boolean | boolean;
  has_embedding?: boolean | boolean;
  id?: boolean | boolean;
  is_flagged?: boolean | boolean;
  keywords?: boolean | boolean;
  month?: boolean | boolean;
  page_count?: boolean | boolean;
  pdf_url?: boolean | boolean;
  published_at?: boolean | boolean;
  published_in?: boolean | boolean;
  research_embedding?:
    | boolean
    | {
        select?: ResearchEmbeddingsSelection;
        include?: ResearchEmbeddingsSelection;
      };
  summary?: boolean | boolean;
  table_count?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  version?: boolean | boolean;
  year?: boolean | boolean;
}

export const includeResearch = <T extends ResearchSelection>(include: T) =>
  include;

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

export interface ResearchAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ResearchAggregateFieldsSelection;
        include?: ResearchAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeResearchAggregate = <T extends ResearchAggregateSelection>(
  include: T,
) => include;

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

export interface ResearchAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ResearchAvgFieldsSelection;
        include?: ResearchAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ResearchMaxFieldsSelection;
        include?: ResearchMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ResearchMinFieldsSelection;
        include?: ResearchMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ResearchStddevFieldsSelection;
        include?: ResearchStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ResearchStddevPopFieldsSelection;
        include?: ResearchStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ResearchStddevSampFieldsSelection;
        include?: ResearchStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ResearchSumFieldsSelection;
        include?: ResearchSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ResearchVarPopFieldsSelection;
        include?: ResearchVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ResearchVarSampFieldsSelection;
        include?: ResearchVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ResearchVarianceFieldsSelection;
        include?: ResearchVarianceFieldsSelection;
      };
}

export const includeResearchAggregateFields = <
  T extends ResearchAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchAvgFieldsSelection {
  figure_count?: boolean | boolean;
  page_count?: boolean | boolean;
  table_count?: boolean | boolean;
  version?: boolean | boolean;
}

export const includeResearchAvgFields = <T extends ResearchAvgFieldsSelection>(
  include: T,
) => include;

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

export interface ResearchEmbeddingsSelection {
  chunk?: boolean | boolean;
  created_at?: boolean | boolean;
  embedding?: boolean | boolean;
  embedding_review?:
    | boolean
    | {
        select?: EmbeddingReviewsSelection;
        include?: EmbeddingReviewsSelection;
      };
  embedding_review_id?: boolean | boolean;
  id?: boolean | boolean;
  is_flagged?: boolean | boolean;
  research?: boolean | boolean;
  research_id?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeResearchEmbeddings = <
  T extends ResearchEmbeddingsSelection,
>(
  include: T,
) => include;

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

export interface ResearchEmbeddingsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ResearchEmbeddingsAggregateFieldsSelection;
        include?: ResearchEmbeddingsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeResearchEmbeddingsAggregate = <
  T extends ResearchEmbeddingsAggregateSelection,
>(
  include: T,
) => include;

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

export interface ResearchEmbeddingsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ResearchEmbeddingsAvgFieldsSelection;
        include?: ResearchEmbeddingsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ResearchEmbeddingsMaxFieldsSelection;
        include?: ResearchEmbeddingsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ResearchEmbeddingsMinFieldsSelection;
        include?: ResearchEmbeddingsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ResearchEmbeddingsStddevFieldsSelection;
        include?: ResearchEmbeddingsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ResearchEmbeddingsStddevPopFieldsSelection;
        include?: ResearchEmbeddingsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ResearchEmbeddingsStddevSampFieldsSelection;
        include?: ResearchEmbeddingsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ResearchEmbeddingsSumFieldsSelection;
        include?: ResearchEmbeddingsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ResearchEmbeddingsVarPopFieldsSelection;
        include?: ResearchEmbeddingsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ResearchEmbeddingsVarSampFieldsSelection;
        include?: ResearchEmbeddingsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ResearchEmbeddingsVarianceFieldsSelection;
        include?: ResearchEmbeddingsVarianceFieldsSelection;
      };
}

export const includeResearchEmbeddingsAggregateFields = <
  T extends ResearchEmbeddingsAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchEmbeddingsAvgFieldsSelection {
  embedding_review_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeResearchEmbeddingsAvgFields = <
  T extends ResearchEmbeddingsAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchEmbeddingsMaxFieldsSelection {
  chunk?: boolean | boolean;
  created_at?: boolean | boolean;
  embedding_review_id?: boolean | boolean;
  id?: boolean | boolean;
  research_id?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeResearchEmbeddingsMaxFields = <
  T extends ResearchEmbeddingsMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchEmbeddingsMinFieldsSelection {
  chunk?: boolean | boolean;
  created_at?: boolean | boolean;
  embedding_review_id?: boolean | boolean;
  id?: boolean | boolean;
  research_id?: boolean | boolean;
  updated_at?: boolean | boolean;
  url?: boolean | boolean;
}

export const includeResearchEmbeddingsMinFields = <
  T extends ResearchEmbeddingsMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeResearchEmbeddingsMutationResponse = <
  T extends ResearchEmbeddingsMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface ResearchEmbeddingsStddevFieldsSelection {
  embedding_review_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeResearchEmbeddingsStddevFields = <
  T extends ResearchEmbeddingsStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchEmbeddingsStddevPopFieldsSelection {
  embedding_review_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeResearchEmbeddingsStddevPopFields = <
  T extends ResearchEmbeddingsStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchEmbeddingsStddevSampFieldsSelection {
  embedding_review_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeResearchEmbeddingsStddevSampFields = <
  T extends ResearchEmbeddingsStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchEmbeddingsSumFieldsSelection {
  embedding_review_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeResearchEmbeddingsSumFields = <
  T extends ResearchEmbeddingsSumFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchEmbeddingsVarPopFieldsSelection {
  embedding_review_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeResearchEmbeddingsVarPopFields = <
  T extends ResearchEmbeddingsVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchEmbeddingsVarSampFieldsSelection {
  embedding_review_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeResearchEmbeddingsVarSampFields = <
  T extends ResearchEmbeddingsVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchEmbeddingsVarianceFieldsSelection {
  embedding_review_id?: boolean | boolean;
  id?: boolean | boolean;
}

export const includeResearchEmbeddingsVarianceFields = <
  T extends ResearchEmbeddingsVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchMaxFieldsSelection {
  abstract?: boolean | boolean;
  abstract_url?: boolean | boolean;
  category?: boolean | boolean;
  comments?: boolean | boolean;
  content_status?: boolean | boolean;
  created_at?: boolean | boolean;
  doi_url?: boolean | boolean;
  figure_count?: boolean | boolean;
  id?: boolean | boolean;
  keywords?: boolean | boolean;
  month?: boolean | boolean;
  page_count?: boolean | boolean;
  pdf_url?: boolean | boolean;
  published_at?: boolean | boolean;
  published_in?: boolean | boolean;
  summary?: boolean | boolean;
  table_count?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  version?: boolean | boolean;
  year?: boolean | boolean;
}

export const includeResearchMaxFields = <T extends ResearchMaxFieldsSelection>(
  include: T,
) => include;

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

export interface ResearchMinFieldsSelection {
  abstract?: boolean | boolean;
  abstract_url?: boolean | boolean;
  category?: boolean | boolean;
  comments?: boolean | boolean;
  content_status?: boolean | boolean;
  created_at?: boolean | boolean;
  doi_url?: boolean | boolean;
  figure_count?: boolean | boolean;
  id?: boolean | boolean;
  keywords?: boolean | boolean;
  month?: boolean | boolean;
  page_count?: boolean | boolean;
  pdf_url?: boolean | boolean;
  published_at?: boolean | boolean;
  published_in?: boolean | boolean;
  summary?: boolean | boolean;
  table_count?: boolean | boolean;
  title?: boolean | boolean;
  updated_at?: boolean | boolean;
  version?: boolean | boolean;
  year?: boolean | boolean;
}

export const includeResearchMinFields = <T extends ResearchMinFieldsSelection>(
  include: T,
) => include;

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

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

export const includeResearchMutationResponse = <
  T extends ResearchMutationResponseSelection,
>(
  include: T,
) => include;

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

export interface ResearchStddevFieldsSelection {
  figure_count?: boolean | boolean;
  page_count?: boolean | boolean;
  table_count?: boolean | boolean;
  version?: boolean | boolean;
}

export const includeResearchStddevFields = <
  T extends ResearchStddevFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchStddevPopFieldsSelection {
  figure_count?: boolean | boolean;
  page_count?: boolean | boolean;
  table_count?: boolean | boolean;
  version?: boolean | boolean;
}

export const includeResearchStddevPopFields = <
  T extends ResearchStddevPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchStddevSampFieldsSelection {
  figure_count?: boolean | boolean;
  page_count?: boolean | boolean;
  table_count?: boolean | boolean;
  version?: boolean | boolean;
}

export const includeResearchStddevSampFields = <
  T extends ResearchStddevSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchSumFieldsSelection {
  figure_count?: boolean | boolean;
  page_count?: boolean | boolean;
  table_count?: boolean | boolean;
  version?: boolean | boolean;
}

export const includeResearchSumFields = <T extends ResearchSumFieldsSelection>(
  include: T,
) => include;

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

export interface ResearchVarPopFieldsSelection {
  figure_count?: boolean | boolean;
  page_count?: boolean | boolean;
  table_count?: boolean | boolean;
  version?: boolean | boolean;
}

export const includeResearchVarPopFields = <
  T extends ResearchVarPopFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchVarSampFieldsSelection {
  figure_count?: boolean | boolean;
  page_count?: boolean | boolean;
  table_count?: boolean | boolean;
  version?: boolean | boolean;
}

export const includeResearchVarSampFields = <
  T extends ResearchVarSampFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResearchVarianceFieldsSelection {
  figure_count?: boolean | boolean;
  page_count?: boolean | boolean;
  table_count?: boolean | boolean;
  version?: boolean | boolean;
}

export const includeResearchVarianceFields = <
  T extends ResearchVarianceFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResponsesSelection {
  created_at?: boolean | boolean;
  downvotes?: boolean | boolean;
  id?: boolean | boolean;
  output?: boolean | boolean;
  search?: boolean | boolean;
  search_id?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeResponses = <T extends ResponsesSelection>(include: T) =>
  include;

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

export interface ResponsesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ResponsesAggregateFieldsSelection;
        include?: ResponsesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeResponsesAggregate = <
  T extends ResponsesAggregateSelection,
>(
  include: T,
) => include;

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

export interface ResponsesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ResponsesAvgFieldsSelection;
        include?: ResponsesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ResponsesMaxFieldsSelection;
        include?: ResponsesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ResponsesMinFieldsSelection;
        include?: ResponsesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ResponsesStddevFieldsSelection;
        include?: ResponsesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ResponsesStddevPopFieldsSelection;
        include?: ResponsesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ResponsesStddevSampFieldsSelection;
        include?: ResponsesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ResponsesSumFieldsSelection;
        include?: ResponsesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ResponsesVarPopFieldsSelection;
        include?: ResponsesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ResponsesVarSampFieldsSelection;
        include?: ResponsesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ResponsesVarianceFieldsSelection;
        include?: ResponsesVarianceFieldsSelection;
      };
}

export const includeResponsesAggregateFields = <
  T extends ResponsesAggregateFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResponsesAvgFieldsSelection {
  downvotes?: boolean | boolean;
  id?: boolean | boolean;
  search_id?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeResponsesAvgFields = <
  T extends ResponsesAvgFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResponsesMaxFieldsSelection {
  created_at?: boolean | boolean;
  downvotes?: boolean | boolean;
  id?: boolean | boolean;
  output?: boolean | boolean;
  search_id?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeResponsesMaxFields = <
  T extends ResponsesMaxFieldsSelection,
>(
  include: T,
) => include;

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

export interface ResponsesMinFieldsSelection {
  created_at?: boolean | boolean;
  downvotes?: boolean | boolean;
  id?: boolean | boolean;
  output?: boolean | boolean;
  search_id?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeResponsesMinFields = <
  T extends ResponsesMinFieldsSelection,
>(
  include: T,
) => include;

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

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

export const includeResponsesMutationResponse = <
  T extends ResponsesMutationResponseSelection,
>(
  include: T,
) => include;

export const selectResponsesStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ResponsesStddevFieldsSelection {
  downvotes?: boolean | boolean;
  id?: boolean | boolean;
  search_id?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeResponsesStddevFields = <
  T extends ResponsesStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectResponsesStddevPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ResponsesStddevPopFieldsSelection {
  downvotes?: boolean | boolean;
  id?: boolean | boolean;
  search_id?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeResponsesStddevPopFields = <
  T extends ResponsesStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectResponsesStddevSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ResponsesStddevSampFieldsSelection {
  downvotes?: boolean | boolean;
  id?: boolean | boolean;
  search_id?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeResponsesStddevSampFields = <
  T extends ResponsesStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectResponsesSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ResponsesSumFieldsSelection {
  downvotes?: boolean | boolean;
  id?: boolean | boolean;
  search_id?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeResponsesSumFields = <
  T extends ResponsesSumFieldsSelection,
>(
  include: T,
) => include;

export const selectResponsesVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ResponsesVarPopFieldsSelection {
  downvotes?: boolean | boolean;
  id?: boolean | boolean;
  search_id?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeResponsesVarPopFields = <
  T extends ResponsesVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectResponsesVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ResponsesVarSampFieldsSelection {
  downvotes?: boolean | boolean;
  id?: boolean | boolean;
  search_id?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeResponsesVarSampFields = <
  T extends ResponsesVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectResponsesVarianceFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ResponsesVarianceFieldsSelection {
  downvotes?: boolean | boolean;
  id?: boolean | boolean;
  search_id?: boolean | boolean;
  upvotes?: boolean | boolean;
}

export const includeResponsesVarianceFields = <
  T extends ResponsesVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectRoleHierarchy = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface RoleHierarchySelection {
  child_role?: boolean | boolean;
  parent_role?: boolean | boolean;
}

export const includeRoleHierarchy = <T extends RoleHierarchySelection>(
  include: T,
) => include;

export const selectRoleHierarchyAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface RoleHierarchyAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: RoleHierarchyAggregateFieldsSelection;
        include?: RoleHierarchyAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeRoleHierarchyAggregate = <
  T extends RoleHierarchyAggregateSelection,
>(
  include: T,
) => include;

export const selectRoleHierarchyAggregateFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface RoleHierarchyAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: RoleHierarchyMaxFieldsSelection;
        include?: RoleHierarchyMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: RoleHierarchyMinFieldsSelection;
        include?: RoleHierarchyMinFieldsSelection;
      };
}

export const includeRoleHierarchyAggregateFields = <
  T extends RoleHierarchyAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectRoleHierarchyMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface RoleHierarchyMaxFieldsSelection {
  child_role?: boolean | boolean;
  parent_role?: boolean | boolean;
}

export const includeRoleHierarchyMaxFields = <
  T extends RoleHierarchyMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectRoleHierarchyMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface RoleHierarchyMinFieldsSelection {
  child_role?: boolean | boolean;
  parent_role?: boolean | boolean;
}

export const includeRoleHierarchyMinFields = <
  T extends RoleHierarchyMinFieldsSelection,
>(
  include: T,
) => include;

export const selectRoleHierarchyMutationResponse = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface RoleHierarchyMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeRoleHierarchyMutationResponse = <
  T extends RoleHierarchyMutationResponseSelection,
>(
  include: T,
) => include;

export const selectRolePermissions = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface RolePermissionsSelection {
  cached_permissions?: boolean | boolean;
  conditions?: boolean | boolean;
  id?: boolean | boolean;
  inherit_from?: boolean | boolean;
  last_updated?: boolean | boolean;
  permissions?: boolean | boolean;
  role?: boolean | boolean;
  table_name?: boolean | boolean;
}

export const includeRolePermissions = <T extends RolePermissionsSelection>(
  include: T,
) => include;

export const selectRolePermissionsAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface RolePermissionsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: RolePermissionsAggregateFieldsSelection;
        include?: RolePermissionsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeRolePermissionsAggregate = <
  T extends RolePermissionsAggregateSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsAggregateFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface RolePermissionsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: RolePermissionsAvgFieldsSelection;
        include?: RolePermissionsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: RolePermissionsMaxFieldsSelection;
        include?: RolePermissionsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: RolePermissionsMinFieldsSelection;
        include?: RolePermissionsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: RolePermissionsStddevFieldsSelection;
        include?: RolePermissionsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: RolePermissionsStddevPopFieldsSelection;
        include?: RolePermissionsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: RolePermissionsStddevSampFieldsSelection;
        include?: RolePermissionsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: RolePermissionsSumFieldsSelection;
        include?: RolePermissionsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: RolePermissionsVarPopFieldsSelection;
        include?: RolePermissionsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: RolePermissionsVarSampFieldsSelection;
        include?: RolePermissionsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: RolePermissionsVarianceFieldsSelection;
        include?: RolePermissionsVarianceFieldsSelection;
      };
}

export const includeRolePermissionsAggregateFields = <
  T extends RolePermissionsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface RolePermissionsAvgFieldsSelection {
  id?: boolean | boolean;
}

export const includeRolePermissionsAvgFields = <
  T extends RolePermissionsAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsMaterialized = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface RolePermissionsMaterializedSelection {
  last_updated?: boolean | boolean;
  permissions?: boolean | boolean;
  role?: boolean | boolean;
}

export const includeRolePermissionsMaterialized = <
  T extends RolePermissionsMaterializedSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsMaterializedAggregate = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface RolePermissionsMaterializedAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: RolePermissionsMaterializedAggregateFieldsSelection;
        include?: RolePermissionsMaterializedAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeRolePermissionsMaterializedAggregate = <
  T extends RolePermissionsMaterializedAggregateSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsMaterializedAggregateFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface RolePermissionsMaterializedAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: RolePermissionsMaterializedMaxFieldsSelection;
        include?: RolePermissionsMaterializedMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: RolePermissionsMaterializedMinFieldsSelection;
        include?: RolePermissionsMaterializedMinFieldsSelection;
      };
}

export const includeRolePermissionsMaterializedAggregateFields = <
  T extends RolePermissionsMaterializedAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsMaterializedMaxFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface RolePermissionsMaterializedMaxFieldsSelection {
  last_updated?: boolean | boolean;
  role?: boolean | boolean;
}

export const includeRolePermissionsMaterializedMaxFields = <
  T extends RolePermissionsMaterializedMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsMaterializedMinFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface RolePermissionsMaterializedMinFieldsSelection {
  last_updated?: boolean | boolean;
  role?: boolean | boolean;
}

export const includeRolePermissionsMaterializedMinFields = <
  T extends RolePermissionsMaterializedMinFieldsSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsMaterializedMutationResponse = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface RolePermissionsMaterializedMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeRolePermissionsMaterializedMutationResponse = <
  T extends RolePermissionsMaterializedMutationResponseSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface RolePermissionsMaxFieldsSelection {
  id?: boolean | boolean;
  inherit_from?: boolean | boolean;
  last_updated?: boolean | boolean;
  role?: boolean | boolean;
  table_name?: boolean | boolean;
}

export const includeRolePermissionsMaxFields = <
  T extends RolePermissionsMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface RolePermissionsMinFieldsSelection {
  id?: boolean | boolean;
  inherit_from?: boolean | boolean;
  last_updated?: boolean | boolean;
  role?: boolean | boolean;
  table_name?: boolean | boolean;
}

export const includeRolePermissionsMinFields = <
  T extends RolePermissionsMinFieldsSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsMutationResponse = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface RolePermissionsMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeRolePermissionsMutationResponse = <
  T extends RolePermissionsMutationResponseSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface RolePermissionsStddevFieldsSelection {
  id?: boolean | boolean;
}

export const includeRolePermissionsStddevFields = <
  T extends RolePermissionsStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsStddevPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface RolePermissionsStddevPopFieldsSelection {
  id?: boolean | boolean;
}

export const includeRolePermissionsStddevPopFields = <
  T extends RolePermissionsStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsStddevSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface RolePermissionsStddevSampFieldsSelection {
  id?: boolean | boolean;
}

export const includeRolePermissionsStddevSampFields = <
  T extends RolePermissionsStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface RolePermissionsSumFieldsSelection {
  id?: boolean | boolean;
}

export const includeRolePermissionsSumFields = <
  T extends RolePermissionsSumFieldsSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface RolePermissionsVarPopFieldsSelection {
  id?: boolean | boolean;
}

export const includeRolePermissionsVarPopFields = <
  T extends RolePermissionsVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface RolePermissionsVarSampFieldsSelection {
  id?: boolean | boolean;
}

export const includeRolePermissionsVarSampFields = <
  T extends RolePermissionsVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectRolePermissionsVarianceFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface RolePermissionsVarianceFieldsSelection {
  id?: boolean | boolean;
}

export const includeRolePermissionsVarianceFields = <
  T extends RolePermissionsVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectScoringWeights = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ScoringWeightsSelection {
  description?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  updated_at?: boolean | boolean;
  weight?: boolean | boolean;
}

export const includeScoringWeights = <T extends ScoringWeightsSelection>(
  include: T,
) => include;

export const selectScoringWeightsAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ScoringWeightsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: ScoringWeightsAggregateFieldsSelection;
        include?: ScoringWeightsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeScoringWeightsAggregate = <
  T extends ScoringWeightsAggregateSelection,
>(
  include: T,
) => include;

export const selectScoringWeightsAggregateFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface ScoringWeightsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: ScoringWeightsAvgFieldsSelection;
        include?: ScoringWeightsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: ScoringWeightsMaxFieldsSelection;
        include?: ScoringWeightsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: ScoringWeightsMinFieldsSelection;
        include?: ScoringWeightsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: ScoringWeightsStddevFieldsSelection;
        include?: ScoringWeightsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: ScoringWeightsStddevPopFieldsSelection;
        include?: ScoringWeightsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: ScoringWeightsStddevSampFieldsSelection;
        include?: ScoringWeightsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: ScoringWeightsSumFieldsSelection;
        include?: ScoringWeightsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: ScoringWeightsVarPopFieldsSelection;
        include?: ScoringWeightsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: ScoringWeightsVarSampFieldsSelection;
        include?: ScoringWeightsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: ScoringWeightsVarianceFieldsSelection;
        include?: ScoringWeightsVarianceFieldsSelection;
      };
}

export const includeScoringWeightsAggregateFields = <
  T extends ScoringWeightsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectScoringWeightsAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ScoringWeightsAvgFieldsSelection {
  weight?: boolean | boolean;
}

export const includeScoringWeightsAvgFields = <
  T extends ScoringWeightsAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectScoringWeightsMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ScoringWeightsMaxFieldsSelection {
  description?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  updated_at?: boolean | boolean;
  weight?: boolean | boolean;
}

export const includeScoringWeightsMaxFields = <
  T extends ScoringWeightsMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectScoringWeightsMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ScoringWeightsMinFieldsSelection {
  description?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  updated_at?: boolean | boolean;
  weight?: boolean | boolean;
}

export const includeScoringWeightsMinFields = <
  T extends ScoringWeightsMinFieldsSelection,
>(
  include: T,
) => include;

export const selectScoringWeightsMutationResponse = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface ScoringWeightsMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeScoringWeightsMutationResponse = <
  T extends ScoringWeightsMutationResponseSelection,
>(
  include: T,
) => include;

export const selectScoringWeightsStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ScoringWeightsStddevFieldsSelection {
  weight?: boolean | boolean;
}

export const includeScoringWeightsStddevFields = <
  T extends ScoringWeightsStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectScoringWeightsStddevPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface ScoringWeightsStddevPopFieldsSelection {
  weight?: boolean | boolean;
}

export const includeScoringWeightsStddevPopFields = <
  T extends ScoringWeightsStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectScoringWeightsStddevSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface ScoringWeightsStddevSampFieldsSelection {
  weight?: boolean | boolean;
}

export const includeScoringWeightsStddevSampFields = <
  T extends ScoringWeightsStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectScoringWeightsSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ScoringWeightsSumFieldsSelection {
  weight?: boolean | boolean;
}

export const includeScoringWeightsSumFields = <
  T extends ScoringWeightsSumFieldsSelection,
>(
  include: T,
) => include;

export const selectScoringWeightsVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ScoringWeightsVarPopFieldsSelection {
  weight?: boolean | boolean;
}

export const includeScoringWeightsVarPopFields = <
  T extends ScoringWeightsVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectScoringWeightsVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ScoringWeightsVarSampFieldsSelection {
  weight?: boolean | boolean;
}

export const includeScoringWeightsVarSampFields = <
  T extends ScoringWeightsVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectScoringWeightsVarianceFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface ScoringWeightsVarianceFieldsSelection {
  weight?: boolean | boolean;
}

export const includeScoringWeightsVarianceFields = <
  T extends ScoringWeightsVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectSearches = <T extends FieldSelection<T>>(selection: T) =>
  selection;

export interface SearchesSelection {
  created_at?: boolean | boolean;
  embedding?: boolean | boolean;
  id?: boolean | boolean;
  input?: boolean | boolean;
  responses?: boolean | boolean;
  responses_aggregate?: boolean | boolean;
  tokens_used?: boolean | boolean;
  user_ids?: boolean | boolean;
}

export const includeSearches = <T extends SearchesSelection>(include: T) =>
  include;

export const selectSearchesAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SearchesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: SearchesAggregateFieldsSelection;
        include?: SearchesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeSearchesAggregate = <T extends SearchesAggregateSelection>(
  include: T,
) => include;

export const selectSearchesAggregateFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SearchesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: SearchesAvgFieldsSelection;
        include?: SearchesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: SearchesMaxFieldsSelection;
        include?: SearchesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: SearchesMinFieldsSelection;
        include?: SearchesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: SearchesStddevFieldsSelection;
        include?: SearchesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: SearchesStddevPopFieldsSelection;
        include?: SearchesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: SearchesStddevSampFieldsSelection;
        include?: SearchesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: SearchesSumFieldsSelection;
        include?: SearchesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: SearchesVarPopFieldsSelection;
        include?: SearchesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: SearchesVarSampFieldsSelection;
        include?: SearchesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: SearchesVarianceFieldsSelection;
        include?: SearchesVarianceFieldsSelection;
      };
}

export const includeSearchesAggregateFields = <
  T extends SearchesAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectSearchesAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SearchesAvgFieldsSelection {
  id?: boolean | boolean;
  tokens_used?: boolean | boolean;
}

export const includeSearchesAvgFields = <T extends SearchesAvgFieldsSelection>(
  include: T,
) => include;

export const selectSearchesMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SearchesMaxFieldsSelection {
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  input?: boolean | boolean;
  tokens_used?: boolean | boolean;
  user_ids?: boolean | boolean;
}

export const includeSearchesMaxFields = <T extends SearchesMaxFieldsSelection>(
  include: T,
) => include;

export const selectSearchesMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SearchesMinFieldsSelection {
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  input?: boolean | boolean;
  tokens_used?: boolean | boolean;
  user_ids?: boolean | boolean;
}

export const includeSearchesMinFields = <T extends SearchesMinFieldsSelection>(
  include: T,
) => include;

export const selectSearchesMutationResponse = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SearchesMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeSearchesMutationResponse = <
  T extends SearchesMutationResponseSelection,
>(
  include: T,
) => include;

export const selectSearchesStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SearchesStddevFieldsSelection {
  id?: boolean | boolean;
  tokens_used?: boolean | boolean;
}

export const includeSearchesStddevFields = <
  T extends SearchesStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectSearchesStddevPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SearchesStddevPopFieldsSelection {
  id?: boolean | boolean;
  tokens_used?: boolean | boolean;
}

export const includeSearchesStddevPopFields = <
  T extends SearchesStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectSearchesStddevSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SearchesStddevSampFieldsSelection {
  id?: boolean | boolean;
  tokens_used?: boolean | boolean;
}

export const includeSearchesStddevSampFields = <
  T extends SearchesStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectSearchesSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SearchesSumFieldsSelection {
  id?: boolean | boolean;
  tokens_used?: boolean | boolean;
}

export const includeSearchesSumFields = <T extends SearchesSumFieldsSelection>(
  include: T,
) => include;

export const selectSearchesVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SearchesVarPopFieldsSelection {
  id?: boolean | boolean;
  tokens_used?: boolean | boolean;
}

export const includeSearchesVarPopFields = <
  T extends SearchesVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectSearchesVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SearchesVarSampFieldsSelection {
  id?: boolean | boolean;
  tokens_used?: boolean | boolean;
}

export const includeSearchesVarSampFields = <
  T extends SearchesVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectSearchesVarianceFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SearchesVarianceFieldsSelection {
  id?: boolean | boolean;
  tokens_used?: boolean | boolean;
}

export const includeSearchesVarianceFields = <
  T extends SearchesVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectSecurityMetrics = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SecurityMetricsSelection {
  high_attempt_count?: boolean | boolean;
  max_attempts?: boolean | boolean;
  suspicious_attempts?: boolean | boolean;
  time_bucket?: boolean | boolean;
  total_attempts?: boolean | boolean;
  unique_ips?: boolean | boolean;
  unique_referrers?: boolean | boolean;
}

export const includeSecurityMetrics = <T extends SecurityMetricsSelection>(
  include: T,
) => include;

export const selectSecurityMetricsAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SecurityMetricsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: SecurityMetricsAggregateFieldsSelection;
        include?: SecurityMetricsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeSecurityMetricsAggregate = <
  T extends SecurityMetricsAggregateSelection,
>(
  include: T,
) => include;

export const selectSecurityMetricsAggregateFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface SecurityMetricsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: SecurityMetricsAvgFieldsSelection;
        include?: SecurityMetricsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: SecurityMetricsMaxFieldsSelection;
        include?: SecurityMetricsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: SecurityMetricsMinFieldsSelection;
        include?: SecurityMetricsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: SecurityMetricsStddevFieldsSelection;
        include?: SecurityMetricsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: SecurityMetricsStddevPopFieldsSelection;
        include?: SecurityMetricsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: SecurityMetricsStddevSampFieldsSelection;
        include?: SecurityMetricsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: SecurityMetricsSumFieldsSelection;
        include?: SecurityMetricsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: SecurityMetricsVarPopFieldsSelection;
        include?: SecurityMetricsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: SecurityMetricsVarSampFieldsSelection;
        include?: SecurityMetricsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: SecurityMetricsVarianceFieldsSelection;
        include?: SecurityMetricsVarianceFieldsSelection;
      };
}

export const includeSecurityMetricsAggregateFields = <
  T extends SecurityMetricsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectSecurityMetricsAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SecurityMetricsAvgFieldsSelection {
  high_attempt_count?: boolean | boolean;
  max_attempts?: boolean | boolean;
  suspicious_attempts?: boolean | boolean;
  total_attempts?: boolean | boolean;
  unique_ips?: boolean | boolean;
  unique_referrers?: boolean | boolean;
}

export const includeSecurityMetricsAvgFields = <
  T extends SecurityMetricsAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectSecurityMetricsMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SecurityMetricsMaxFieldsSelection {
  high_attempt_count?: boolean | boolean;
  max_attempts?: boolean | boolean;
  suspicious_attempts?: boolean | boolean;
  time_bucket?: boolean | boolean;
  total_attempts?: boolean | boolean;
  unique_ips?: boolean | boolean;
  unique_referrers?: boolean | boolean;
}

export const includeSecurityMetricsMaxFields = <
  T extends SecurityMetricsMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectSecurityMetricsMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SecurityMetricsMinFieldsSelection {
  high_attempt_count?: boolean | boolean;
  max_attempts?: boolean | boolean;
  suspicious_attempts?: boolean | boolean;
  time_bucket?: boolean | boolean;
  total_attempts?: boolean | boolean;
  unique_ips?: boolean | boolean;
  unique_referrers?: boolean | boolean;
}

export const includeSecurityMetricsMinFields = <
  T extends SecurityMetricsMinFieldsSelection,
>(
  include: T,
) => include;

export const selectSecurityMetricsStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SecurityMetricsStddevFieldsSelection {
  high_attempt_count?: boolean | boolean;
  max_attempts?: boolean | boolean;
  suspicious_attempts?: boolean | boolean;
  total_attempts?: boolean | boolean;
  unique_ips?: boolean | boolean;
  unique_referrers?: boolean | boolean;
}

export const includeSecurityMetricsStddevFields = <
  T extends SecurityMetricsStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectSecurityMetricsStddevPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface SecurityMetricsStddevPopFieldsSelection {
  high_attempt_count?: boolean | boolean;
  max_attempts?: boolean | boolean;
  suspicious_attempts?: boolean | boolean;
  total_attempts?: boolean | boolean;
  unique_ips?: boolean | boolean;
  unique_referrers?: boolean | boolean;
}

export const includeSecurityMetricsStddevPopFields = <
  T extends SecurityMetricsStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectSecurityMetricsStddevSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface SecurityMetricsStddevSampFieldsSelection {
  high_attempt_count?: boolean | boolean;
  max_attempts?: boolean | boolean;
  suspicious_attempts?: boolean | boolean;
  total_attempts?: boolean | boolean;
  unique_ips?: boolean | boolean;
  unique_referrers?: boolean | boolean;
}

export const includeSecurityMetricsStddevSampFields = <
  T extends SecurityMetricsStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectSecurityMetricsSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SecurityMetricsSumFieldsSelection {
  high_attempt_count?: boolean | boolean;
  max_attempts?: boolean | boolean;
  suspicious_attempts?: boolean | boolean;
  total_attempts?: boolean | boolean;
  unique_ips?: boolean | boolean;
  unique_referrers?: boolean | boolean;
}

export const includeSecurityMetricsSumFields = <
  T extends SecurityMetricsSumFieldsSelection,
>(
  include: T,
) => include;

export const selectSecurityMetricsVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SecurityMetricsVarPopFieldsSelection {
  high_attempt_count?: boolean | boolean;
  max_attempts?: boolean | boolean;
  suspicious_attempts?: boolean | boolean;
  total_attempts?: boolean | boolean;
  unique_ips?: boolean | boolean;
  unique_referrers?: boolean | boolean;
}

export const includeSecurityMetricsVarPopFields = <
  T extends SecurityMetricsVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectSecurityMetricsVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SecurityMetricsVarSampFieldsSelection {
  high_attempt_count?: boolean | boolean;
  max_attempts?: boolean | boolean;
  suspicious_attempts?: boolean | boolean;
  total_attempts?: boolean | boolean;
  unique_ips?: boolean | boolean;
  unique_referrers?: boolean | boolean;
}

export const includeSecurityMetricsVarSampFields = <
  T extends SecurityMetricsVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectSecurityMetricsVarianceFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface SecurityMetricsVarianceFieldsSelection {
  high_attempt_count?: boolean | boolean;
  max_attempts?: boolean | boolean;
  suspicious_attempts?: boolean | boolean;
  total_attempts?: boolean | boolean;
  unique_ips?: boolean | boolean;
  unique_referrers?: boolean | boolean;
}

export const includeSecurityMetricsVarianceFields = <
  T extends SecurityMetricsVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectSlowQueryPatterns = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SlowQueryPatternsSelection {
  avg_exec_time?: boolean | boolean;
  first_seen?: boolean | boolean;
  last_seen?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  occurrence_count?: boolean | boolean;
  query_id?: boolean | boolean;
}

export const includeSlowQueryPatterns = <T extends SlowQueryPatternsSelection>(
  include: T,
) => include;

export const selectSlowQueryPatternsAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SlowQueryPatternsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: SlowQueryPatternsAggregateFieldsSelection;
        include?: SlowQueryPatternsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeSlowQueryPatternsAggregate = <
  T extends SlowQueryPatternsAggregateSelection,
>(
  include: T,
) => include;

export const selectSlowQueryPatternsAggregateFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface SlowQueryPatternsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: SlowQueryPatternsAvgFieldsSelection;
        include?: SlowQueryPatternsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: SlowQueryPatternsMaxFieldsSelection;
        include?: SlowQueryPatternsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: SlowQueryPatternsMinFieldsSelection;
        include?: SlowQueryPatternsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: SlowQueryPatternsStddevFieldsSelection;
        include?: SlowQueryPatternsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: SlowQueryPatternsStddevPopFieldsSelection;
        include?: SlowQueryPatternsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: SlowQueryPatternsStddevSampFieldsSelection;
        include?: SlowQueryPatternsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: SlowQueryPatternsSumFieldsSelection;
        include?: SlowQueryPatternsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: SlowQueryPatternsVarPopFieldsSelection;
        include?: SlowQueryPatternsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: SlowQueryPatternsVarSampFieldsSelection;
        include?: SlowQueryPatternsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: SlowQueryPatternsVarianceFieldsSelection;
        include?: SlowQueryPatternsVarianceFieldsSelection;
      };
}

export const includeSlowQueryPatternsAggregateFields = <
  T extends SlowQueryPatternsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectSlowQueryPatternsAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SlowQueryPatternsAvgFieldsSelection {
  avg_exec_time?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeSlowQueryPatternsAvgFields = <
  T extends SlowQueryPatternsAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectSlowQueryPatternsMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SlowQueryPatternsMaxFieldsSelection {
  avg_exec_time?: boolean | boolean;
  first_seen?: boolean | boolean;
  last_seen?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  occurrence_count?: boolean | boolean;
  query_id?: boolean | boolean;
}

export const includeSlowQueryPatternsMaxFields = <
  T extends SlowQueryPatternsMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectSlowQueryPatternsMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SlowQueryPatternsMinFieldsSelection {
  avg_exec_time?: boolean | boolean;
  first_seen?: boolean | boolean;
  last_seen?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  occurrence_count?: boolean | boolean;
  query_id?: boolean | boolean;
}

export const includeSlowQueryPatternsMinFields = <
  T extends SlowQueryPatternsMinFieldsSelection,
>(
  include: T,
) => include;

export const selectSlowQueryPatternsStddevFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface SlowQueryPatternsStddevFieldsSelection {
  avg_exec_time?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeSlowQueryPatternsStddevFields = <
  T extends SlowQueryPatternsStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectSlowQueryPatternsStddevPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface SlowQueryPatternsStddevPopFieldsSelection {
  avg_exec_time?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeSlowQueryPatternsStddevPopFields = <
  T extends SlowQueryPatternsStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectSlowQueryPatternsStddevSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface SlowQueryPatternsStddevSampFieldsSelection {
  avg_exec_time?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeSlowQueryPatternsStddevSampFields = <
  T extends SlowQueryPatternsStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectSlowQueryPatternsSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SlowQueryPatternsSumFieldsSelection {
  avg_exec_time?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeSlowQueryPatternsSumFields = <
  T extends SlowQueryPatternsSumFieldsSelection,
>(
  include: T,
) => include;

export const selectSlowQueryPatternsVarPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface SlowQueryPatternsVarPopFieldsSelection {
  avg_exec_time?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeSlowQueryPatternsVarPopFields = <
  T extends SlowQueryPatternsVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectSlowQueryPatternsVarSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface SlowQueryPatternsVarSampFieldsSelection {
  avg_exec_time?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeSlowQueryPatternsVarSampFields = <
  T extends SlowQueryPatternsVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectSlowQueryPatternsVarianceFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface SlowQueryPatternsVarianceFieldsSelection {
  avg_exec_time?: boolean | boolean;
  max_exec_time?: boolean | boolean;
  occurrence_count?: boolean | boolean;
}

export const includeSlowQueryPatternsVarianceFields = <
  T extends SlowQueryPatternsVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectSocialMedia = <T extends FieldSelection<T>>(selection: T) =>
  selection;

export interface SocialMediaSelection {
  companies?: boolean | boolean;
  companies_aggregate?: boolean | boolean;
  created_at?: boolean | boolean;
  facebook_url?: boolean | boolean;
  id?: boolean | boolean;
  instagram_url?: boolean | boolean;
  linkedin_url?: boolean | boolean;
  twitter_url?: boolean | boolean;
  updated_at?: boolean | boolean;
  youtube_url?: boolean | boolean;
}

export const includeSocialMedia = <T extends SocialMediaSelection>(
  include: T,
) => include;

export const selectSocialMediaAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SocialMediaAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: SocialMediaAggregateFieldsSelection;
        include?: SocialMediaAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeSocialMediaAggregate = <
  T extends SocialMediaAggregateSelection,
>(
  include: T,
) => include;

export const selectSocialMediaAggregateFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SocialMediaAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: SocialMediaAvgFieldsSelection;
        include?: SocialMediaAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: SocialMediaMaxFieldsSelection;
        include?: SocialMediaMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: SocialMediaMinFieldsSelection;
        include?: SocialMediaMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: SocialMediaStddevFieldsSelection;
        include?: SocialMediaStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: SocialMediaStddevPopFieldsSelection;
        include?: SocialMediaStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: SocialMediaStddevSampFieldsSelection;
        include?: SocialMediaStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: SocialMediaSumFieldsSelection;
        include?: SocialMediaSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: SocialMediaVarPopFieldsSelection;
        include?: SocialMediaVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: SocialMediaVarSampFieldsSelection;
        include?: SocialMediaVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: SocialMediaVarianceFieldsSelection;
        include?: SocialMediaVarianceFieldsSelection;
      };
}

export const includeSocialMediaAggregateFields = <
  T extends SocialMediaAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectSocialMediaAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SocialMediaAvgFieldsSelection {
  id?: boolean | boolean;
}

export const includeSocialMediaAvgFields = <
  T extends SocialMediaAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectSocialMediaMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SocialMediaMaxFieldsSelection {
  created_at?: boolean | boolean;
  facebook_url?: boolean | boolean;
  id?: boolean | boolean;
  instagram_url?: boolean | boolean;
  linkedin_url?: boolean | boolean;
  twitter_url?: boolean | boolean;
  updated_at?: boolean | boolean;
  youtube_url?: boolean | boolean;
}

export const includeSocialMediaMaxFields = <
  T extends SocialMediaMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectSocialMediaMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SocialMediaMinFieldsSelection {
  created_at?: boolean | boolean;
  facebook_url?: boolean | boolean;
  id?: boolean | boolean;
  instagram_url?: boolean | boolean;
  linkedin_url?: boolean | boolean;
  twitter_url?: boolean | boolean;
  updated_at?: boolean | boolean;
  youtube_url?: boolean | boolean;
}

export const includeSocialMediaMinFields = <
  T extends SocialMediaMinFieldsSelection,
>(
  include: T,
) => include;

export const selectSocialMediaMutationResponse = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SocialMediaMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeSocialMediaMutationResponse = <
  T extends SocialMediaMutationResponseSelection,
>(
  include: T,
) => include;

export const selectSocialMediaStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SocialMediaStddevFieldsSelection {
  id?: boolean | boolean;
}

export const includeSocialMediaStddevFields = <
  T extends SocialMediaStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectSocialMediaStddevPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SocialMediaStddevPopFieldsSelection {
  id?: boolean | boolean;
}

export const includeSocialMediaStddevPopFields = <
  T extends SocialMediaStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectSocialMediaStddevSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SocialMediaStddevSampFieldsSelection {
  id?: boolean | boolean;
}

export const includeSocialMediaStddevSampFields = <
  T extends SocialMediaStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectSocialMediaSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SocialMediaSumFieldsSelection {
  id?: boolean | boolean;
}

export const includeSocialMediaSumFields = <
  T extends SocialMediaSumFieldsSelection,
>(
  include: T,
) => include;

export const selectSocialMediaVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SocialMediaVarPopFieldsSelection {
  id?: boolean | boolean;
}

export const includeSocialMediaVarPopFields = <
  T extends SocialMediaVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectSocialMediaVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SocialMediaVarSampFieldsSelection {
  id?: boolean | boolean;
}

export const includeSocialMediaVarSampFields = <
  T extends SocialMediaVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectSocialMediaVarianceFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SocialMediaVarianceFieldsSelection {
  id?: boolean | boolean;
}

export const includeSocialMediaVarianceFields = <
  T extends SocialMediaVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectSpiderMetrics = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SpiderMetricsSelection {
  crawl_id?: boolean | boolean;
  id?: boolean | boolean;
  metric_definition?:
    | boolean
    | {
        select?: MetricDefinitionsSelection;
        include?: MetricDefinitionsSelection;
      };
  metric_id?: boolean | boolean;
  timestamp?: boolean | boolean;
  value?: boolean | boolean;
}

export const includeSpiderMetrics = <T extends SpiderMetricsSelection>(
  include: T,
) => include;

export const selectSpiderMetricsAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SpiderMetricsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: SpiderMetricsAggregateFieldsSelection;
        include?: SpiderMetricsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeSpiderMetricsAggregate = <
  T extends SpiderMetricsAggregateSelection,
>(
  include: T,
) => include;

export const selectSpiderMetricsAggregateFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SpiderMetricsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: SpiderMetricsAvgFieldsSelection;
        include?: SpiderMetricsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: SpiderMetricsMaxFieldsSelection;
        include?: SpiderMetricsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: SpiderMetricsMinFieldsSelection;
        include?: SpiderMetricsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: SpiderMetricsStddevFieldsSelection;
        include?: SpiderMetricsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: SpiderMetricsStddevPopFieldsSelection;
        include?: SpiderMetricsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: SpiderMetricsStddevSampFieldsSelection;
        include?: SpiderMetricsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: SpiderMetricsSumFieldsSelection;
        include?: SpiderMetricsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: SpiderMetricsVarPopFieldsSelection;
        include?: SpiderMetricsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: SpiderMetricsVarSampFieldsSelection;
        include?: SpiderMetricsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: SpiderMetricsVarianceFieldsSelection;
        include?: SpiderMetricsVarianceFieldsSelection;
      };
}

export const includeSpiderMetricsAggregateFields = <
  T extends SpiderMetricsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectSpiderMetricsAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SpiderMetricsAvgFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeSpiderMetricsAvgFields = <
  T extends SpiderMetricsAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectSpiderMetricsMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SpiderMetricsMaxFieldsSelection {
  crawl_id?: boolean | boolean;
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
  timestamp?: boolean | boolean;
}

export const includeSpiderMetricsMaxFields = <
  T extends SpiderMetricsMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectSpiderMetricsMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SpiderMetricsMinFieldsSelection {
  crawl_id?: boolean | boolean;
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
  timestamp?: boolean | boolean;
}

export const includeSpiderMetricsMinFields = <
  T extends SpiderMetricsMinFieldsSelection,
>(
  include: T,
) => include;

export const selectSpiderMetricsMutationResponse = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface SpiderMetricsMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeSpiderMetricsMutationResponse = <
  T extends SpiderMetricsMutationResponseSelection,
>(
  include: T,
) => include;

export const selectSpiderMetricsStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SpiderMetricsStddevFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeSpiderMetricsStddevFields = <
  T extends SpiderMetricsStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectSpiderMetricsStddevPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SpiderMetricsStddevPopFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeSpiderMetricsStddevPopFields = <
  T extends SpiderMetricsStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectSpiderMetricsStddevSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface SpiderMetricsStddevSampFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeSpiderMetricsStddevSampFields = <
  T extends SpiderMetricsStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectSpiderMetricsSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SpiderMetricsSumFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeSpiderMetricsSumFields = <
  T extends SpiderMetricsSumFieldsSelection,
>(
  include: T,
) => include;

export const selectSpiderMetricsVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SpiderMetricsVarPopFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeSpiderMetricsVarPopFields = <
  T extends SpiderMetricsVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectSpiderMetricsVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SpiderMetricsVarSampFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeSpiderMetricsVarSampFields = <
  T extends SpiderMetricsVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectSpiderMetricsVarianceFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SpiderMetricsVarianceFieldsSelection {
  id?: boolean | boolean;
  metric_id?: boolean | boolean;
}

export const includeSpiderMetricsVarianceFields = <
  T extends SpiderMetricsVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrations = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface StrapiMigrationsSelection {
  id?: boolean | boolean;
  name?: boolean | boolean;
  time?: boolean | boolean;
}

export const includeStrapiMigrations = <T extends StrapiMigrationsSelection>(
  include: T,
) => include;

export const selectStrapiMigrationsAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface StrapiMigrationsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: StrapiMigrationsAggregateFieldsSelection;
        include?: StrapiMigrationsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeStrapiMigrationsAggregate = <
  T extends StrapiMigrationsAggregateSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsAggregateFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: StrapiMigrationsAvgFieldsSelection;
        include?: StrapiMigrationsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: StrapiMigrationsMaxFieldsSelection;
        include?: StrapiMigrationsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: StrapiMigrationsMinFieldsSelection;
        include?: StrapiMigrationsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: StrapiMigrationsStddevFieldsSelection;
        include?: StrapiMigrationsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: StrapiMigrationsStddevPopFieldsSelection;
        include?: StrapiMigrationsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: StrapiMigrationsStddevSampFieldsSelection;
        include?: StrapiMigrationsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: StrapiMigrationsSumFieldsSelection;
        include?: StrapiMigrationsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: StrapiMigrationsVarPopFieldsSelection;
        include?: StrapiMigrationsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: StrapiMigrationsVarSampFieldsSelection;
        include?: StrapiMigrationsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: StrapiMigrationsVarianceFieldsSelection;
        include?: StrapiMigrationsVarianceFieldsSelection;
      };
}

export const includeStrapiMigrationsAggregateFields = <
  T extends StrapiMigrationsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface StrapiMigrationsAvgFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsAvgFields = <
  T extends StrapiMigrationsAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsInternal = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface StrapiMigrationsInternalSelection {
  id?: boolean | boolean;
  name?: boolean | boolean;
  time?: boolean | boolean;
}

export const includeStrapiMigrationsInternal = <
  T extends StrapiMigrationsInternalSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsInternalAggregate = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsInternalAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: StrapiMigrationsInternalAggregateFieldsSelection;
        include?: StrapiMigrationsInternalAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeStrapiMigrationsInternalAggregate = <
  T extends StrapiMigrationsInternalAggregateSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsInternalAggregateFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsInternalAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: StrapiMigrationsInternalAvgFieldsSelection;
        include?: StrapiMigrationsInternalAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: StrapiMigrationsInternalMaxFieldsSelection;
        include?: StrapiMigrationsInternalMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: StrapiMigrationsInternalMinFieldsSelection;
        include?: StrapiMigrationsInternalMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: StrapiMigrationsInternalStddevFieldsSelection;
        include?: StrapiMigrationsInternalStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: StrapiMigrationsInternalStddevPopFieldsSelection;
        include?: StrapiMigrationsInternalStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: StrapiMigrationsInternalStddevSampFieldsSelection;
        include?: StrapiMigrationsInternalStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: StrapiMigrationsInternalSumFieldsSelection;
        include?: StrapiMigrationsInternalSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: StrapiMigrationsInternalVarPopFieldsSelection;
        include?: StrapiMigrationsInternalVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: StrapiMigrationsInternalVarSampFieldsSelection;
        include?: StrapiMigrationsInternalVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: StrapiMigrationsInternalVarianceFieldsSelection;
        include?: StrapiMigrationsInternalVarianceFieldsSelection;
      };
}

export const includeStrapiMigrationsInternalAggregateFields = <
  T extends StrapiMigrationsInternalAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsInternalAvgFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsInternalAvgFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsInternalAvgFields = <
  T extends StrapiMigrationsInternalAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsInternalMaxFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsInternalMaxFieldsSelection {
  id?: boolean | boolean;
  name?: boolean | boolean;
  time?: boolean | boolean;
}

export const includeStrapiMigrationsInternalMaxFields = <
  T extends StrapiMigrationsInternalMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsInternalMinFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsInternalMinFieldsSelection {
  id?: boolean | boolean;
  name?: boolean | boolean;
  time?: boolean | boolean;
}

export const includeStrapiMigrationsInternalMinFields = <
  T extends StrapiMigrationsInternalMinFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsInternalMutationResponse = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsInternalMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeStrapiMigrationsInternalMutationResponse = <
  T extends StrapiMigrationsInternalMutationResponseSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsInternalStddevFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsInternalStddevFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsInternalStddevFields = <
  T extends StrapiMigrationsInternalStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsInternalStddevPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsInternalStddevPopFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsInternalStddevPopFields = <
  T extends StrapiMigrationsInternalStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsInternalStddevSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsInternalStddevSampFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsInternalStddevSampFields = <
  T extends StrapiMigrationsInternalStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsInternalSumFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsInternalSumFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsInternalSumFields = <
  T extends StrapiMigrationsInternalSumFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsInternalVarPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsInternalVarPopFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsInternalVarPopFields = <
  T extends StrapiMigrationsInternalVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsInternalVarSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsInternalVarSampFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsInternalVarSampFields = <
  T extends StrapiMigrationsInternalVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsInternalVarianceFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsInternalVarianceFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsInternalVarianceFields = <
  T extends StrapiMigrationsInternalVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface StrapiMigrationsMaxFieldsSelection {
  id?: boolean | boolean;
  name?: boolean | boolean;
  time?: boolean | boolean;
}

export const includeStrapiMigrationsMaxFields = <
  T extends StrapiMigrationsMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface StrapiMigrationsMinFieldsSelection {
  id?: boolean | boolean;
  name?: boolean | boolean;
  time?: boolean | boolean;
}

export const includeStrapiMigrationsMinFields = <
  T extends StrapiMigrationsMinFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsMutationResponse = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeStrapiMigrationsMutationResponse = <
  T extends StrapiMigrationsMutationResponseSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface StrapiMigrationsStddevFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsStddevFields = <
  T extends StrapiMigrationsStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsStddevPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsStddevPopFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsStddevPopFields = <
  T extends StrapiMigrationsStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsStddevSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsStddevSampFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsStddevSampFields = <
  T extends StrapiMigrationsStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface StrapiMigrationsSumFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsSumFields = <
  T extends StrapiMigrationsSumFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface StrapiMigrationsVarPopFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsVarPopFields = <
  T extends StrapiMigrationsVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsVarSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsVarSampFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsVarSampFields = <
  T extends StrapiMigrationsVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectStrapiMigrationsVarianceFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface StrapiMigrationsVarianceFieldsSelection {
  id?: boolean | boolean;
}

export const includeStrapiMigrationsVarianceFields = <
  T extends StrapiMigrationsVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectSubscriptionRoot = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface SubscriptionRootSelection {
  ad_daily_metrics?: boolean | boolean;
  ad_daily_metrics_aggregate?: boolean | boolean;
  ad_daily_metrics_by_pk?:
    | boolean
    | {
        select?: AdDailyMetricsSelection;
        include?: AdDailyMetricsSelection;
      };
  ad_daily_metrics_stream?: boolean | boolean;
  ad_packages?: boolean | boolean;
  ad_packages_aggregate?: boolean | boolean;
  ad_packages_by_pk?:
    | boolean
    | {
        select?: AdPackagesSelection;
        include?: AdPackagesSelection;
      };
  ad_packages_stream?: boolean | boolean;
  ad_variants?: boolean | boolean;
  ad_variants_aggregate?: boolean | boolean;
  ad_variants_by_pk?:
    | boolean
    | {
        select?: AdVariantsSelection;
        include?: AdVariantsSelection;
      };
  ad_variants_stream?: boolean | boolean;
  addresses?: boolean | boolean;
  addresses_aggregate?: boolean | boolean;
  addresses_by_pk?:
    | boolean
    | {
        select?: AddressesSelection;
        include?: AddressesSelection;
      };
  addresses_stream?: boolean | boolean;
  ads?: boolean | boolean;
  ads_aggregate?: boolean | boolean;
  ads_by_pk?:
    | boolean
    | {
        select?: AdsSelection;
        include?: AdsSelection;
      };
  ads_stream?: boolean | boolean;
  blacklisted_domains?: boolean | boolean;
  blacklisted_domains_aggregate?: boolean | boolean;
  blacklisted_domains_by_pk?:
    | boolean
    | {
        select?: BlacklistedDomainsSelection;
        include?: BlacklistedDomainsSelection;
      };
  blacklisted_domains_stream?: boolean | boolean;
  blacklisted_urls?: boolean | boolean;
  blacklisted_urls_aggregate?: boolean | boolean;
  blacklisted_urls_by_pk?:
    | boolean
    | {
        select?: BlacklistedUrlsSelection;
        include?: BlacklistedUrlsSelection;
      };
  blacklisted_urls_stream?: boolean | boolean;
  blocked_ips?: boolean | boolean;
  blocked_ips_aggregate?: boolean | boolean;
  blocked_ips_by_pk?:
    | boolean
    | {
        select?: BlockedIpsSelection;
        include?: BlockedIpsSelection;
      };
  blocked_ips_stream?: boolean | boolean;
  bookmark_folders?: boolean | boolean;
  bookmark_folders_aggregate?: boolean | boolean;
  bookmark_folders_by_pk?:
    | boolean
    | {
        select?: BookmarkFoldersSelection;
        include?: BookmarkFoldersSelection;
      };
  bookmark_folders_stream?: boolean | boolean;
  bookmarks?: boolean | boolean;
  bookmarks_aggregate?: boolean | boolean;
  bookmarks_by_pk?:
    | boolean
    | {
        select?: BookmarksSelection;
        include?: BookmarksSelection;
      };
  bookmarks_stream?: boolean | boolean;
  business_domains?: boolean | boolean;
  business_domains_aggregate?: boolean | boolean;
  business_domains_by_pk?:
    | boolean
    | {
        select?: BusinessDomainsSelection;
        include?: BusinessDomainsSelection;
      };
  business_domains_stream?: boolean | boolean;
  categories?: boolean | boolean;
  categories_aggregate?: boolean | boolean;
  categories_by_pk?:
    | boolean
    | {
        select?: CategoriesSelection;
        include?: CategoriesSelection;
      };
  categories_stream?: boolean | boolean;
  categorized_urls?: boolean | boolean;
  categorized_urls_aggregate?: boolean | boolean;
  categorized_urls_by_pk?:
    | boolean
    | {
        select?: CategorizedUrlsSelection;
        include?: CategorizedUrlsSelection;
      };
  categorized_urls_stream?: boolean | boolean;
  circuit_breaker_states?: boolean | boolean;
  circuit_breaker_states_aggregate?: boolean | boolean;
  circuit_breaker_states_by_pk?:
    | boolean
    | {
        select?: CircuitBreakerStatesSelection;
        include?: CircuitBreakerStatesSelection;
      };
  circuit_breaker_states_stream?: boolean | boolean;
  cities?: boolean | boolean;
  cities_aggregate?: boolean | boolean;
  cities_by_pk?:
    | boolean
    | {
        select?: CitiesSelection;
        include?: CitiesSelection;
      };
  cities_stream?: boolean | boolean;
  comments?: boolean | boolean;
  comments_aggregate?: boolean | boolean;
  comments_by_pk?:
    | boolean
    | {
        select?: CommentsSelection;
        include?: CommentsSelection;
      };
  comments_stream?: boolean | boolean;
  companies?: boolean | boolean;
  companies_aggregate?: boolean | boolean;
  companies_by_pk?:
    | boolean
    | {
        select?: CompaniesSelection;
        include?: CompaniesSelection;
      };
  companies_stream?: boolean | boolean;
  company_contacts?: boolean | boolean;
  company_contacts_aggregate?: boolean | boolean;
  company_contacts_by_pk?:
    | boolean
    | {
        select?: CompanyContactsSelection;
        include?: CompanyContactsSelection;
      };
  company_contacts_stream?: boolean | boolean;
  company_employees?: boolean | boolean;
  company_employees_aggregate?: boolean | boolean;
  company_employees_by_pk?:
    | boolean
    | {
        select?: CompanyEmployeesSelection;
        include?: CompanyEmployeesSelection;
      };
  company_employees_stream?: boolean | boolean;
  company_extras?: boolean | boolean;
  company_extras_aggregate?: boolean | boolean;
  company_extras_by_pk?:
    | boolean
    | {
        select?: CompanyExtrasSelection;
        include?: CompanyExtrasSelection;
      };
  company_extras_stream?: boolean | boolean;
  company_metrics?: boolean | boolean;
  company_metrics_aggregate?: boolean | boolean;
  company_metrics_by_pk?:
    | boolean
    | {
        select?: CompanyMetricsSelection;
        include?: CompanyMetricsSelection;
      };
  company_metrics_stream?: boolean | boolean;
  contacts?: boolean | boolean;
  contacts_aggregate?: boolean | boolean;
  contacts_by_pk?:
    | boolean
    | {
        select?: ContactsSelection;
        include?: ContactsSelection;
      };
  contacts_stream?: boolean | boolean;
  content_categories?: boolean | boolean;
  content_categories_aggregate?: boolean | boolean;
  content_categories_by_pk?:
    | boolean
    | {
        select?: ContentCategoriesSelection;
        include?: ContentCategoriesSelection;
      };
  content_categories_stream?: boolean | boolean;
  content_scores?: boolean | boolean;
  content_scores_aggregate?: boolean | boolean;
  content_scores_stream?: boolean | boolean;
  content_source_visits?: boolean | boolean;
  content_source_visits_aggregate?: boolean | boolean;
  content_source_visits_by_pk?:
    | boolean
    | {
        select?: ContentSourceVisitsSelection;
        include?: ContentSourceVisitsSelection;
      };
  content_source_visits_stream?: boolean | boolean;
  content_sources?: boolean | boolean;
  content_sources_aggregate?: boolean | boolean;
  content_sources_by_pk?:
    | boolean
    | {
        select?: ContentSourcesSelection;
        include?: ContentSourcesSelection;
      };
  content_sources_stream?: boolean | boolean;
  content_statuses?: boolean | boolean;
  content_statuses_aggregate?: boolean | boolean;
  content_statuses_by_pk?:
    | boolean
    | {
        select?: ContentStatusesSelection;
        include?: ContentStatusesSelection;
      };
  content_statuses_stream?: boolean | boolean;
  content_tags?: boolean | boolean;
  content_tags_aggregate?: boolean | boolean;
  content_tags_by_pk?:
    | boolean
    | {
        select?: ContentTagsSelection;
        include?: ContentTagsSelection;
      };
  content_tags_stream?: boolean | boolean;
  contents?: boolean | boolean;
  contents_aggregate?: boolean | boolean;
  contents_by_pk?:
    | boolean
    | {
        select?: ContentsSelection;
        include?: ContentsSelection;
      };
  contents_stream?: boolean | boolean;
  countries?: boolean | boolean;
  countries_aggregate?: boolean | boolean;
  countries_by_pk?:
    | boolean
    | {
        select?: CountriesSelection;
        include?: CountriesSelection;
      };
  countries_stream?: boolean | boolean;
  customer_payments?: boolean | boolean;
  customer_payments_aggregate?: boolean | boolean;
  customer_payments_by_pk?:
    | boolean
    | {
        select?: CustomerPaymentsSelection;
        include?: CustomerPaymentsSelection;
      };
  customer_payments_stream?: boolean | boolean;
  customer_processed_webhooks?: boolean | boolean;
  customer_processed_webhooks_aggregate?: boolean | boolean;
  customer_processed_webhooks_by_pk?:
    | boolean
    | {
        select?: CustomerProcessedWebhooksSelection;
        include?: CustomerProcessedWebhooksSelection;
      };
  customer_processed_webhooks_stream?: boolean | boolean;
  customer_refunds?: boolean | boolean;
  customer_refunds_aggregate?: boolean | boolean;
  customer_refunds_by_pk?:
    | boolean
    | {
        select?: CustomerRefundsSelection;
        include?: CustomerRefundsSelection;
      };
  customer_refunds_stream?: boolean | boolean;
  customer_subscription_plans?: boolean | boolean;
  customer_subscription_plans_aggregate?: boolean | boolean;
  customer_subscription_plans_by_pk?:
    | boolean
    | {
        select?: CustomerSubscriptionPlansSelection;
        include?: CustomerSubscriptionPlansSelection;
      };
  customer_subscription_plans_stream?: boolean | boolean;
  customer_subscriptions?: boolean | boolean;
  customer_subscriptions_aggregate?: boolean | boolean;
  customer_subscriptions_by_pk?:
    | boolean
    | {
        select?: CustomerSubscriptionsSelection;
        include?: CustomerSubscriptionsSelection;
      };
  customer_subscriptions_stream?: boolean | boolean;
  embedding_reviews?: boolean | boolean;
  embedding_reviews_aggregate?: boolean | boolean;
  embedding_reviews_by_pk?:
    | boolean
    | {
        select?: EmbeddingReviewsSelection;
        include?: EmbeddingReviewsSelection;
      };
  embedding_reviews_stream?: boolean | boolean;
  error_correlations?: boolean | boolean;
  error_correlations_aggregate?: boolean | boolean;
  error_correlations_stream?: boolean | boolean;
  error_frequency?: boolean | boolean;
  error_frequency_aggregate?: boolean | boolean;
  error_frequency_stream?: boolean | boolean;
  error_logs?: boolean | boolean;
  error_logs_aggregate?: boolean | boolean;
  error_logs_by_pk?:
    | boolean
    | {
        select?: ErrorLogsSelection;
        include?: ErrorLogsSelection;
      };
  error_logs_stream?: boolean | boolean;
  error_metrics?: boolean | boolean;
  error_metrics_aggregate?: boolean | boolean;
  error_metrics_stream?: boolean | boolean;
  error_patterns?: boolean | boolean;
  error_patterns_aggregate?: boolean | boolean;
  error_patterns_stream?: boolean | boolean;
  error_stats?: boolean | boolean;
  error_stats_aggregate?: boolean | boolean;
  error_stats_stream?: boolean | boolean;
  feature_requests?: boolean | boolean;
  feature_requests_aggregate?: boolean | boolean;
  feature_requests_by_pk?:
    | boolean
    | {
        select?: FeatureRequestsSelection;
        include?: FeatureRequestsSelection;
      };
  feature_requests_stream?: boolean | boolean;
  feature_votes?: boolean | boolean;
  feature_votes_aggregate?: boolean | boolean;
  feature_votes_by_pk?:
    | boolean
    | {
        select?: FeatureVotesSelection;
        include?: FeatureVotesSelection;
      };
  feature_votes_stream?: boolean | boolean;
  feed_categories?: boolean | boolean;
  feed_categories_aggregate?: boolean | boolean;
  feed_categories_by_pk?:
    | boolean
    | {
        select?: FeedCategoriesSelection;
        include?: FeedCategoriesSelection;
      };
  feed_categories_stream?: boolean | boolean;
  feed_sources?: boolean | boolean;
  feed_sources_aggregate?: boolean | boolean;
  feed_sources_by_pk?:
    | boolean
    | {
        select?: FeedSourcesSelection;
        include?: FeedSourcesSelection;
      };
  feed_sources_stream?: boolean | boolean;
  feedbacks?: boolean | boolean;
  feedbacks_aggregate?: boolean | boolean;
  feedbacks_by_pk?:
    | boolean
    | {
        select?: FeedbacksSelection;
        include?: FeedbacksSelection;
      };
  feedbacks_stream?: boolean | boolean;
  feeds?: boolean | boolean;
  feeds_aggregate?: boolean | boolean;
  feeds_by_pk?:
    | boolean
    | {
        select?: FeedsSelection;
        include?: FeedsSelection;
      };
  feeds_stream?: boolean | boolean;
  follows?: boolean | boolean;
  follows_aggregate?: boolean | boolean;
  follows_by_pk?:
    | boolean
    | {
        select?: FollowsSelection;
        include?: FollowsSelection;
      };
  follows_stream?: boolean | boolean;
  metric_definitions?: boolean | boolean;
  metric_definitions_aggregate?: boolean | boolean;
  metric_definitions_by_pk?:
    | boolean
    | {
        select?: MetricDefinitionsSelection;
        include?: MetricDefinitionsSelection;
      };
  metric_definitions_stream?: boolean | boolean;
  news?: boolean | boolean;
  news_aggregate?: boolean | boolean;
  news_by_pk?:
    | boolean
    | {
        select?: NewsSelection;
        include?: NewsSelection;
      };
  news_details?: boolean | boolean;
  news_details_aggregate?: boolean | boolean;
  news_details_stream?: boolean | boolean;
  news_stream?: boolean | boolean;
  news_summaries?: boolean | boolean;
  news_summaries_aggregate?: boolean | boolean;
  news_summaries_by_pk?:
    | boolean
    | {
        select?: NewsSummariesSelection;
        include?: NewsSummariesSelection;
      };
  news_summaries_stream?: boolean | boolean;
  news_tags?: boolean | boolean;
  news_tags_aggregate?: boolean | boolean;
  news_tags_by_pk?:
    | boolean
    | {
        select?: NewsTagsSelection;
        include?: NewsTagsSelection;
      };
  news_tags_stream?: boolean | boolean;
  newsletters?: boolean | boolean;
  newsletters_aggregate?: boolean | boolean;
  newsletters_by_pk?:
    | boolean
    | {
        select?: NewslettersSelection;
        include?: NewslettersSelection;
      };
  newsletters_stream?: boolean | boolean;
  payment_providers?: boolean | boolean;
  payment_providers_aggregate?: boolean | boolean;
  payment_providers_by_pk?:
    | boolean
    | {
        select?: PaymentProvidersSelection;
        include?: PaymentProvidersSelection;
      };
  payment_providers_stream?: boolean | boolean;
  plan_permissions?: boolean | boolean;
  plan_permissions_aggregate?: boolean | boolean;
  plan_permissions_by_pk?:
    | boolean
    | {
        select?: PlanPermissionsSelection;
        include?: PlanPermissionsSelection;
      };
  plan_permissions_stream?: boolean | boolean;
  recent_errors?: boolean | boolean;
  recent_errors_aggregate?: boolean | boolean;
  recent_errors_stream?: boolean | boolean;
  referral_stats?: boolean | boolean;
  referral_stats_aggregate?: boolean | boolean;
  referral_stats_stream?: boolean | boolean;
  referrals?: boolean | boolean;
  referrals_aggregate?: boolean | boolean;
  referrals_by_pk?:
    | boolean
    | {
        select?: ReferralsSelection;
        include?: ReferralsSelection;
      };
  referrals_stream?: boolean | boolean;
  referrer_blocks?: boolean | boolean;
  referrer_blocks_aggregate?: boolean | boolean;
  referrer_blocks_by_pk?:
    | boolean
    | {
        select?: ReferrerBlocksSelection;
        include?: ReferrerBlocksSelection;
      };
  referrer_blocks_stream?: boolean | boolean;
  referrer_risk_metrics?: boolean | boolean;
  referrer_risk_metrics_aggregate?: boolean | boolean;
  referrer_risk_metrics_stream?: boolean | boolean;
  research?: boolean | boolean;
  research_aggregate?: boolean | boolean;
  research_by_pk?:
    | boolean
    | {
        select?: ResearchSelection;
        include?: ResearchSelection;
      };
  research_embeddings?: boolean | boolean;
  research_embeddings_aggregate?: boolean | boolean;
  research_embeddings_by_pk?:
    | boolean
    | {
        select?: ResearchEmbeddingsSelection;
        include?: ResearchEmbeddingsSelection;
      };
  research_embeddings_stream?: boolean | boolean;
  research_stream?: boolean | boolean;
  responses?: boolean | boolean;
  responses_aggregate?: boolean | boolean;
  responses_by_pk?:
    | boolean
    | {
        select?: ResponsesSelection;
        include?: ResponsesSelection;
      };
  responses_stream?: boolean | boolean;
  role_hierarchy?: boolean | boolean;
  role_hierarchy_aggregate?: boolean | boolean;
  role_hierarchy_by_pk?:
    | boolean
    | {
        select?: RoleHierarchySelection;
        include?: RoleHierarchySelection;
      };
  role_hierarchy_stream?: boolean | boolean;
  role_permissions?: boolean | boolean;
  role_permissions_aggregate?: boolean | boolean;
  role_permissions_by_pk?:
    | boolean
    | {
        select?: RolePermissionsSelection;
        include?: RolePermissionsSelection;
      };
  role_permissions_materialized?: boolean | boolean;
  role_permissions_materialized_aggregate?: boolean | boolean;
  role_permissions_materialized_by_pk?:
    | boolean
    | {
        select?: RolePermissionsMaterializedSelection;
        include?: RolePermissionsMaterializedSelection;
      };
  role_permissions_materialized_stream?: boolean | boolean;
  role_permissions_stream?: boolean | boolean;
  scoring_weights?: boolean | boolean;
  scoring_weights_aggregate?: boolean | boolean;
  scoring_weights_by_pk?:
    | boolean
    | {
        select?: ScoringWeightsSelection;
        include?: ScoringWeightsSelection;
      };
  scoring_weights_stream?: boolean | boolean;
  searches?: boolean | boolean;
  searches_aggregate?: boolean | boolean;
  searches_by_pk?:
    | boolean
    | {
        select?: SearchesSelection;
        include?: SearchesSelection;
      };
  searches_stream?: boolean | boolean;
  security_metrics?: boolean | boolean;
  security_metrics_aggregate?: boolean | boolean;
  security_metrics_stream?: boolean | boolean;
  slow_query_patterns?: boolean | boolean;
  slow_query_patterns_aggregate?: boolean | boolean;
  slow_query_patterns_stream?: boolean | boolean;
  social_media?: boolean | boolean;
  social_media_aggregate?: boolean | boolean;
  social_media_by_pk?:
    | boolean
    | {
        select?: SocialMediaSelection;
        include?: SocialMediaSelection;
      };
  social_media_stream?: boolean | boolean;
  spider_metrics?: boolean | boolean;
  spider_metrics_aggregate?: boolean | boolean;
  spider_metrics_by_pk?:
    | boolean
    | {
        select?: SpiderMetricsSelection;
        include?: SpiderMetricsSelection;
      };
  spider_metrics_stream?: boolean | boolean;
  strapi_migrations?: boolean | boolean;
  strapi_migrations_aggregate?: boolean | boolean;
  strapi_migrations_by_pk?:
    | boolean
    | {
        select?: StrapiMigrationsSelection;
        include?: StrapiMigrationsSelection;
      };
  strapi_migrations_internal?: boolean | boolean;
  strapi_migrations_internal_aggregate?: boolean | boolean;
  strapi_migrations_internal_by_pk?:
    | boolean
    | {
        select?: StrapiMigrationsInternalSelection;
        include?: StrapiMigrationsInternalSelection;
      };
  strapi_migrations_internal_stream?: boolean | boolean;
  strapi_migrations_stream?: boolean | boolean;
  table_maintenance_log?: boolean | boolean;
  table_maintenance_log_aggregate?: boolean | boolean;
  table_maintenance_log_by_pk?:
    | boolean
    | {
        select?: TableMaintenanceLogSelection;
        include?: TableMaintenanceLogSelection;
      };
  table_maintenance_log_stream?: boolean | boolean;
  table_query_performance?: boolean | boolean;
  table_query_performance_aggregate?: boolean | boolean;
  table_query_performance_stream?: boolean | boolean;
  table_sequence_usage?: boolean | boolean;
  table_sequence_usage_aggregate?: boolean | boolean;
  table_sequence_usage_stream?: boolean | boolean;
  table_statistics?: boolean | boolean;
  table_statistics_aggregate?: boolean | boolean;
  table_statistics_by_pk?:
    | boolean
    | {
        select?: TableStatisticsSelection;
        include?: TableStatisticsSelection;
      };
  table_statistics_stream?: boolean | boolean;
  tags?: boolean | boolean;
  tags_aggregate?: boolean | boolean;
  tags_by_pk?:
    | boolean
    | {
        select?: TagsSelection;
        include?: TagsSelection;
      };
  tags_stream?: boolean | boolean;
  user_metrics?: boolean | boolean;
  user_metrics_aggregate?: boolean | boolean;
  user_metrics_by_pk?:
    | boolean
    | {
        select?: UserMetricsSelection;
        include?: UserMetricsSelection;
      };
  user_metrics_stream?: boolean | boolean;
  user_profiles?: boolean | boolean;
  user_profiles_aggregate?: boolean | boolean;
  user_profiles_by_pk?:
    | boolean
    | {
        select?: UserProfilesSelection;
        include?: UserProfilesSelection;
      };
  user_profiles_stream?: boolean | boolean;
  votes?: boolean | boolean;
  votes_aggregate?: boolean | boolean;
  votes_by_pk?:
    | boolean
    | {
        select?: VotesSelection;
        include?: VotesSelection;
      };
  votes_stream?: boolean | boolean;
  workflows?: boolean | boolean;
  workflows_aggregate?: boolean | boolean;
  workflows_by_pk?:
    | boolean
    | {
        select?: WorkflowsSelection;
        include?: WorkflowsSelection;
      };
  workflows_stream?: boolean | boolean;
}

export const includeSubscriptionRoot = <T extends SubscriptionRootSelection>(
  include: T,
) => include;

export const selectTableMaintenanceLog = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableMaintenanceLogSelection {
  detail?: boolean | boolean;
  id?: boolean | boolean;
  logged_at?: boolean | boolean;
  operation?: boolean | boolean;
}

export const includeTableMaintenanceLog = <
  T extends TableMaintenanceLogSelection,
>(
  include: T,
) => include;

export const selectTableMaintenanceLogAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableMaintenanceLogAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: TableMaintenanceLogAggregateFieldsSelection;
        include?: TableMaintenanceLogAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeTableMaintenanceLogAggregate = <
  T extends TableMaintenanceLogAggregateSelection,
>(
  include: T,
) => include;

export const selectTableMaintenanceLogAggregateFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableMaintenanceLogAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: TableMaintenanceLogAvgFieldsSelection;
        include?: TableMaintenanceLogAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: TableMaintenanceLogMaxFieldsSelection;
        include?: TableMaintenanceLogMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: TableMaintenanceLogMinFieldsSelection;
        include?: TableMaintenanceLogMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: TableMaintenanceLogStddevFieldsSelection;
        include?: TableMaintenanceLogStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: TableMaintenanceLogStddevPopFieldsSelection;
        include?: TableMaintenanceLogStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: TableMaintenanceLogStddevSampFieldsSelection;
        include?: TableMaintenanceLogStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: TableMaintenanceLogSumFieldsSelection;
        include?: TableMaintenanceLogSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: TableMaintenanceLogVarPopFieldsSelection;
        include?: TableMaintenanceLogVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: TableMaintenanceLogVarSampFieldsSelection;
        include?: TableMaintenanceLogVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: TableMaintenanceLogVarianceFieldsSelection;
        include?: TableMaintenanceLogVarianceFieldsSelection;
      };
}

export const includeTableMaintenanceLogAggregateFields = <
  T extends TableMaintenanceLogAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectTableMaintenanceLogAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableMaintenanceLogAvgFieldsSelection {
  id?: boolean | boolean;
}

export const includeTableMaintenanceLogAvgFields = <
  T extends TableMaintenanceLogAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectTableMaintenanceLogMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableMaintenanceLogMaxFieldsSelection {
  detail?: boolean | boolean;
  id?: boolean | boolean;
  logged_at?: boolean | boolean;
  operation?: boolean | boolean;
}

export const includeTableMaintenanceLogMaxFields = <
  T extends TableMaintenanceLogMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectTableMaintenanceLogMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableMaintenanceLogMinFieldsSelection {
  detail?: boolean | boolean;
  id?: boolean | boolean;
  logged_at?: boolean | boolean;
  operation?: boolean | boolean;
}

export const includeTableMaintenanceLogMinFields = <
  T extends TableMaintenanceLogMinFieldsSelection,
>(
  include: T,
) => include;

export const selectTableMaintenanceLogMutationResponse = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableMaintenanceLogMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeTableMaintenanceLogMutationResponse = <
  T extends TableMaintenanceLogMutationResponseSelection,
>(
  include: T,
) => include;

export const selectTableMaintenanceLogStddevFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableMaintenanceLogStddevFieldsSelection {
  id?: boolean | boolean;
}

export const includeTableMaintenanceLogStddevFields = <
  T extends TableMaintenanceLogStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectTableMaintenanceLogStddevPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableMaintenanceLogStddevPopFieldsSelection {
  id?: boolean | boolean;
}

export const includeTableMaintenanceLogStddevPopFields = <
  T extends TableMaintenanceLogStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectTableMaintenanceLogStddevSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableMaintenanceLogStddevSampFieldsSelection {
  id?: boolean | boolean;
}

export const includeTableMaintenanceLogStddevSampFields = <
  T extends TableMaintenanceLogStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectTableMaintenanceLogSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableMaintenanceLogSumFieldsSelection {
  id?: boolean | boolean;
}

export const includeTableMaintenanceLogSumFields = <
  T extends TableMaintenanceLogSumFieldsSelection,
>(
  include: T,
) => include;

export const selectTableMaintenanceLogVarPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableMaintenanceLogVarPopFieldsSelection {
  id?: boolean | boolean;
}

export const includeTableMaintenanceLogVarPopFields = <
  T extends TableMaintenanceLogVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectTableMaintenanceLogVarSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableMaintenanceLogVarSampFieldsSelection {
  id?: boolean | boolean;
}

export const includeTableMaintenanceLogVarSampFields = <
  T extends TableMaintenanceLogVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectTableMaintenanceLogVarianceFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableMaintenanceLogVarianceFieldsSelection {
  id?: boolean | boolean;
}

export const includeTableMaintenanceLogVarianceFields = <
  T extends TableMaintenanceLogVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectTableQueryPerformance = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableQueryPerformanceSelection {
  avg_duration?: boolean | boolean;
  capture_time?: boolean | boolean;
  execution_count?: boolean | boolean;
  query?: boolean | boolean;
}

export const includeTableQueryPerformance = <
  T extends TableQueryPerformanceSelection,
>(
  include: T,
) => include;

export const selectTableQueryPerformanceAggregate = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableQueryPerformanceAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: TableQueryPerformanceAggregateFieldsSelection;
        include?: TableQueryPerformanceAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeTableQueryPerformanceAggregate = <
  T extends TableQueryPerformanceAggregateSelection,
>(
  include: T,
) => include;

export const selectTableQueryPerformanceAggregateFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableQueryPerformanceAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: TableQueryPerformanceAvgFieldsSelection;
        include?: TableQueryPerformanceAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: TableQueryPerformanceMaxFieldsSelection;
        include?: TableQueryPerformanceMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: TableQueryPerformanceMinFieldsSelection;
        include?: TableQueryPerformanceMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: TableQueryPerformanceStddevFieldsSelection;
        include?: TableQueryPerformanceStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: TableQueryPerformanceStddevPopFieldsSelection;
        include?: TableQueryPerformanceStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: TableQueryPerformanceStddevSampFieldsSelection;
        include?: TableQueryPerformanceStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: TableQueryPerformanceSumFieldsSelection;
        include?: TableQueryPerformanceSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: TableQueryPerformanceVarPopFieldsSelection;
        include?: TableQueryPerformanceVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: TableQueryPerformanceVarSampFieldsSelection;
        include?: TableQueryPerformanceVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: TableQueryPerformanceVarianceFieldsSelection;
        include?: TableQueryPerformanceVarianceFieldsSelection;
      };
}

export const includeTableQueryPerformanceAggregateFields = <
  T extends TableQueryPerformanceAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectTableQueryPerformanceAvgFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableQueryPerformanceAvgFieldsSelection {
  execution_count?: boolean | boolean;
}

export const includeTableQueryPerformanceAvgFields = <
  T extends TableQueryPerformanceAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectTableQueryPerformanceMaxFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableQueryPerformanceMaxFieldsSelection {
  capture_time?: boolean | boolean;
  execution_count?: boolean | boolean;
  query?: boolean | boolean;
}

export const includeTableQueryPerformanceMaxFields = <
  T extends TableQueryPerformanceMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectTableQueryPerformanceMinFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableQueryPerformanceMinFieldsSelection {
  capture_time?: boolean | boolean;
  execution_count?: boolean | boolean;
  query?: boolean | boolean;
}

export const includeTableQueryPerformanceMinFields = <
  T extends TableQueryPerformanceMinFieldsSelection,
>(
  include: T,
) => include;

export const selectTableQueryPerformanceMutationResponse = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableQueryPerformanceMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeTableQueryPerformanceMutationResponse = <
  T extends TableQueryPerformanceMutationResponseSelection,
>(
  include: T,
) => include;

export const selectTableQueryPerformanceStddevFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableQueryPerformanceStddevFieldsSelection {
  execution_count?: boolean | boolean;
}

export const includeTableQueryPerformanceStddevFields = <
  T extends TableQueryPerformanceStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectTableQueryPerformanceStddevPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableQueryPerformanceStddevPopFieldsSelection {
  execution_count?: boolean | boolean;
}

export const includeTableQueryPerformanceStddevPopFields = <
  T extends TableQueryPerformanceStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectTableQueryPerformanceStddevSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableQueryPerformanceStddevSampFieldsSelection {
  execution_count?: boolean | boolean;
}

export const includeTableQueryPerformanceStddevSampFields = <
  T extends TableQueryPerformanceStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectTableQueryPerformanceSumFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableQueryPerformanceSumFieldsSelection {
  execution_count?: boolean | boolean;
}

export const includeTableQueryPerformanceSumFields = <
  T extends TableQueryPerformanceSumFieldsSelection,
>(
  include: T,
) => include;

export const selectTableQueryPerformanceVarPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableQueryPerformanceVarPopFieldsSelection {
  execution_count?: boolean | boolean;
}

export const includeTableQueryPerformanceVarPopFields = <
  T extends TableQueryPerformanceVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectTableQueryPerformanceVarSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableQueryPerformanceVarSampFieldsSelection {
  execution_count?: boolean | boolean;
}

export const includeTableQueryPerformanceVarSampFields = <
  T extends TableQueryPerformanceVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectTableQueryPerformanceVarianceFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableQueryPerformanceVarianceFieldsSelection {
  execution_count?: boolean | boolean;
}

export const includeTableQueryPerformanceVarianceFields = <
  T extends TableQueryPerformanceVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectTableSequenceUsage = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableSequenceUsageSelection {
  capture_time?: boolean | boolean;
  current_value?: boolean | boolean;
  max_value?: boolean | boolean;
  sequence_name?: boolean | boolean;
}

export const includeTableSequenceUsage = <
  T extends TableSequenceUsageSelection,
>(
  include: T,
) => include;

export const selectTableSequenceUsageAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableSequenceUsageAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: TableSequenceUsageAggregateFieldsSelection;
        include?: TableSequenceUsageAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeTableSequenceUsageAggregate = <
  T extends TableSequenceUsageAggregateSelection,
>(
  include: T,
) => include;

export const selectTableSequenceUsageAggregateFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableSequenceUsageAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: TableSequenceUsageAvgFieldsSelection;
        include?: TableSequenceUsageAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: TableSequenceUsageMaxFieldsSelection;
        include?: TableSequenceUsageMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: TableSequenceUsageMinFieldsSelection;
        include?: TableSequenceUsageMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: TableSequenceUsageStddevFieldsSelection;
        include?: TableSequenceUsageStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: TableSequenceUsageStddevPopFieldsSelection;
        include?: TableSequenceUsageStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: TableSequenceUsageStddevSampFieldsSelection;
        include?: TableSequenceUsageStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: TableSequenceUsageSumFieldsSelection;
        include?: TableSequenceUsageSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: TableSequenceUsageVarPopFieldsSelection;
        include?: TableSequenceUsageVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: TableSequenceUsageVarSampFieldsSelection;
        include?: TableSequenceUsageVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: TableSequenceUsageVarianceFieldsSelection;
        include?: TableSequenceUsageVarianceFieldsSelection;
      };
}

export const includeTableSequenceUsageAggregateFields = <
  T extends TableSequenceUsageAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectTableSequenceUsageAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableSequenceUsageAvgFieldsSelection {
  current_value?: boolean | boolean;
  max_value?: boolean | boolean;
}

export const includeTableSequenceUsageAvgFields = <
  T extends TableSequenceUsageAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectTableSequenceUsageMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableSequenceUsageMaxFieldsSelection {
  capture_time?: boolean | boolean;
  current_value?: boolean | boolean;
  max_value?: boolean | boolean;
  sequence_name?: boolean | boolean;
}

export const includeTableSequenceUsageMaxFields = <
  T extends TableSequenceUsageMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectTableSequenceUsageMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableSequenceUsageMinFieldsSelection {
  capture_time?: boolean | boolean;
  current_value?: boolean | boolean;
  max_value?: boolean | boolean;
  sequence_name?: boolean | boolean;
}

export const includeTableSequenceUsageMinFields = <
  T extends TableSequenceUsageMinFieldsSelection,
>(
  include: T,
) => include;

export const selectTableSequenceUsageMutationResponse = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableSequenceUsageMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeTableSequenceUsageMutationResponse = <
  T extends TableSequenceUsageMutationResponseSelection,
>(
  include: T,
) => include;

export const selectTableSequenceUsageStddevFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableSequenceUsageStddevFieldsSelection {
  current_value?: boolean | boolean;
  max_value?: boolean | boolean;
}

export const includeTableSequenceUsageStddevFields = <
  T extends TableSequenceUsageStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectTableSequenceUsageStddevPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableSequenceUsageStddevPopFieldsSelection {
  current_value?: boolean | boolean;
  max_value?: boolean | boolean;
}

export const includeTableSequenceUsageStddevPopFields = <
  T extends TableSequenceUsageStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectTableSequenceUsageStddevSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableSequenceUsageStddevSampFieldsSelection {
  current_value?: boolean | boolean;
  max_value?: boolean | boolean;
}

export const includeTableSequenceUsageStddevSampFields = <
  T extends TableSequenceUsageStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectTableSequenceUsageSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableSequenceUsageSumFieldsSelection {
  current_value?: boolean | boolean;
  max_value?: boolean | boolean;
}

export const includeTableSequenceUsageSumFields = <
  T extends TableSequenceUsageSumFieldsSelection,
>(
  include: T,
) => include;

export const selectTableSequenceUsageVarPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableSequenceUsageVarPopFieldsSelection {
  current_value?: boolean | boolean;
  max_value?: boolean | boolean;
}

export const includeTableSequenceUsageVarPopFields = <
  T extends TableSequenceUsageVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectTableSequenceUsageVarSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableSequenceUsageVarSampFieldsSelection {
  current_value?: boolean | boolean;
  max_value?: boolean | boolean;
}

export const includeTableSequenceUsageVarSampFields = <
  T extends TableSequenceUsageVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectTableSequenceUsageVarianceFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableSequenceUsageVarianceFieldsSelection {
  current_value?: boolean | boolean;
  max_value?: boolean | boolean;
}

export const includeTableSequenceUsageVarianceFields = <
  T extends TableSequenceUsageVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectTableStatistics = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableStatisticsSelection {
  buffer_cache_hit_ratio?: boolean | boolean;
  capture_time?: boolean | boolean;
  dead_tuples?: boolean | boolean;
  estimated_bloat_ratio?: boolean | boolean;
  index_scan_count?: boolean | boolean;
  index_size?: boolean | boolean;
  index_usage?: boolean | boolean;
  last_analyze?: boolean | boolean;
  last_vacuum?: boolean | boolean;
  live_tuples?: boolean | boolean;
  row_count?: boolean | boolean;
  seq_scan_count?: boolean | boolean;
  table_name?: boolean | boolean;
  table_size?: boolean | boolean;
}

export const includeTableStatistics = <T extends TableStatisticsSelection>(
  include: T,
) => include;

export const selectTableStatisticsAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableStatisticsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: TableStatisticsAggregateFieldsSelection;
        include?: TableStatisticsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeTableStatisticsAggregate = <
  T extends TableStatisticsAggregateSelection,
>(
  include: T,
) => include;

export const selectTableStatisticsAggregateFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableStatisticsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: TableStatisticsAvgFieldsSelection;
        include?: TableStatisticsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: TableStatisticsMaxFieldsSelection;
        include?: TableStatisticsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: TableStatisticsMinFieldsSelection;
        include?: TableStatisticsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: TableStatisticsStddevFieldsSelection;
        include?: TableStatisticsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: TableStatisticsStddevPopFieldsSelection;
        include?: TableStatisticsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: TableStatisticsStddevSampFieldsSelection;
        include?: TableStatisticsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: TableStatisticsSumFieldsSelection;
        include?: TableStatisticsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: TableStatisticsVarPopFieldsSelection;
        include?: TableStatisticsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: TableStatisticsVarSampFieldsSelection;
        include?: TableStatisticsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: TableStatisticsVarianceFieldsSelection;
        include?: TableStatisticsVarianceFieldsSelection;
      };
}

export const includeTableStatisticsAggregateFields = <
  T extends TableStatisticsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectTableStatisticsAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableStatisticsAvgFieldsSelection {
  buffer_cache_hit_ratio?: boolean | boolean;
  dead_tuples?: boolean | boolean;
  estimated_bloat_ratio?: boolean | boolean;
  index_scan_count?: boolean | boolean;
  index_size?: boolean | boolean;
  live_tuples?: boolean | boolean;
  row_count?: boolean | boolean;
  seq_scan_count?: boolean | boolean;
  table_size?: boolean | boolean;
}

export const includeTableStatisticsAvgFields = <
  T extends TableStatisticsAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectTableStatisticsMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableStatisticsMaxFieldsSelection {
  buffer_cache_hit_ratio?: boolean | boolean;
  capture_time?: boolean | boolean;
  dead_tuples?: boolean | boolean;
  estimated_bloat_ratio?: boolean | boolean;
  index_scan_count?: boolean | boolean;
  index_size?: boolean | boolean;
  last_analyze?: boolean | boolean;
  last_vacuum?: boolean | boolean;
  live_tuples?: boolean | boolean;
  row_count?: boolean | boolean;
  seq_scan_count?: boolean | boolean;
  table_name?: boolean | boolean;
  table_size?: boolean | boolean;
}

export const includeTableStatisticsMaxFields = <
  T extends TableStatisticsMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectTableStatisticsMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableStatisticsMinFieldsSelection {
  buffer_cache_hit_ratio?: boolean | boolean;
  capture_time?: boolean | boolean;
  dead_tuples?: boolean | boolean;
  estimated_bloat_ratio?: boolean | boolean;
  index_scan_count?: boolean | boolean;
  index_size?: boolean | boolean;
  last_analyze?: boolean | boolean;
  last_vacuum?: boolean | boolean;
  live_tuples?: boolean | boolean;
  row_count?: boolean | boolean;
  seq_scan_count?: boolean | boolean;
  table_name?: boolean | boolean;
  table_size?: boolean | boolean;
}

export const includeTableStatisticsMinFields = <
  T extends TableStatisticsMinFieldsSelection,
>(
  include: T,
) => include;

export const selectTableStatisticsMutationResponse = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableStatisticsMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeTableStatisticsMutationResponse = <
  T extends TableStatisticsMutationResponseSelection,
>(
  include: T,
) => include;

export const selectTableStatisticsStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableStatisticsStddevFieldsSelection {
  buffer_cache_hit_ratio?: boolean | boolean;
  dead_tuples?: boolean | boolean;
  estimated_bloat_ratio?: boolean | boolean;
  index_scan_count?: boolean | boolean;
  index_size?: boolean | boolean;
  live_tuples?: boolean | boolean;
  row_count?: boolean | boolean;
  seq_scan_count?: boolean | boolean;
  table_size?: boolean | boolean;
}

export const includeTableStatisticsStddevFields = <
  T extends TableStatisticsStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectTableStatisticsStddevPopFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableStatisticsStddevPopFieldsSelection {
  buffer_cache_hit_ratio?: boolean | boolean;
  dead_tuples?: boolean | boolean;
  estimated_bloat_ratio?: boolean | boolean;
  index_scan_count?: boolean | boolean;
  index_size?: boolean | boolean;
  live_tuples?: boolean | boolean;
  row_count?: boolean | boolean;
  seq_scan_count?: boolean | boolean;
  table_size?: boolean | boolean;
}

export const includeTableStatisticsStddevPopFields = <
  T extends TableStatisticsStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectTableStatisticsStddevSampFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableStatisticsStddevSampFieldsSelection {
  buffer_cache_hit_ratio?: boolean | boolean;
  dead_tuples?: boolean | boolean;
  estimated_bloat_ratio?: boolean | boolean;
  index_scan_count?: boolean | boolean;
  index_size?: boolean | boolean;
  live_tuples?: boolean | boolean;
  row_count?: boolean | boolean;
  seq_scan_count?: boolean | boolean;
  table_size?: boolean | boolean;
}

export const includeTableStatisticsStddevSampFields = <
  T extends TableStatisticsStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectTableStatisticsSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableStatisticsSumFieldsSelection {
  buffer_cache_hit_ratio?: boolean | boolean;
  dead_tuples?: boolean | boolean;
  estimated_bloat_ratio?: boolean | boolean;
  index_scan_count?: boolean | boolean;
  index_size?: boolean | boolean;
  live_tuples?: boolean | boolean;
  row_count?: boolean | boolean;
  seq_scan_count?: boolean | boolean;
  table_size?: boolean | boolean;
}

export const includeTableStatisticsSumFields = <
  T extends TableStatisticsSumFieldsSelection,
>(
  include: T,
) => include;

export const selectTableStatisticsVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableStatisticsVarPopFieldsSelection {
  buffer_cache_hit_ratio?: boolean | boolean;
  dead_tuples?: boolean | boolean;
  estimated_bloat_ratio?: boolean | boolean;
  index_scan_count?: boolean | boolean;
  index_size?: boolean | boolean;
  live_tuples?: boolean | boolean;
  row_count?: boolean | boolean;
  seq_scan_count?: boolean | boolean;
  table_size?: boolean | boolean;
}

export const includeTableStatisticsVarPopFields = <
  T extends TableStatisticsVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectTableStatisticsVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TableStatisticsVarSampFieldsSelection {
  buffer_cache_hit_ratio?: boolean | boolean;
  dead_tuples?: boolean | boolean;
  estimated_bloat_ratio?: boolean | boolean;
  index_scan_count?: boolean | boolean;
  index_size?: boolean | boolean;
  live_tuples?: boolean | boolean;
  row_count?: boolean | boolean;
  seq_scan_count?: boolean | boolean;
  table_size?: boolean | boolean;
}

export const includeTableStatisticsVarSampFields = <
  T extends TableStatisticsVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectTableStatisticsVarianceFields = <
  T extends FieldSelection<T>,
>(
  selection: T,
) => selection;

export interface TableStatisticsVarianceFieldsSelection {
  buffer_cache_hit_ratio?: boolean | boolean;
  dead_tuples?: boolean | boolean;
  estimated_bloat_ratio?: boolean | boolean;
  index_scan_count?: boolean | boolean;
  index_size?: boolean | boolean;
  live_tuples?: boolean | boolean;
  row_count?: boolean | boolean;
  seq_scan_count?: boolean | boolean;
  table_size?: boolean | boolean;
}

export const includeTableStatisticsVarianceFields = <
  T extends TableStatisticsVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectTags = <T extends FieldSelection<T>>(selection: T) =>
  selection;

export interface TagsSelection {
  body?: boolean | boolean;
  content_tags?: boolean | boolean;
  content_tags_aggregate?: boolean | boolean;
  created_at?: boolean | boolean;
  document_id?: boolean | boolean;
  id?: boolean | boolean;
  locale?: boolean | boolean;
  name?: boolean | boolean;
  news_tags?: boolean | boolean;
  news_tags_aggregate?: boolean | boolean;
  published_at?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeTags = <T extends TagsSelection>(include: T) => include;

export const selectTagsAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TagsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: TagsAggregateFieldsSelection;
        include?: TagsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeTagsAggregate = <T extends TagsAggregateSelection>(
  include: T,
) => include;

export const selectTagsAggregateFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TagsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: TagsAvgFieldsSelection;
        include?: TagsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: TagsMaxFieldsSelection;
        include?: TagsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: TagsMinFieldsSelection;
        include?: TagsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: TagsStddevFieldsSelection;
        include?: TagsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: TagsStddevPopFieldsSelection;
        include?: TagsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: TagsStddevSampFieldsSelection;
        include?: TagsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: TagsSumFieldsSelection;
        include?: TagsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: TagsVarPopFieldsSelection;
        include?: TagsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: TagsVarSampFieldsSelection;
        include?: TagsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: TagsVarianceFieldsSelection;
        include?: TagsVarianceFieldsSelection;
      };
}

export const includeTagsAggregateFields = <
  T extends TagsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectTagsAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TagsAvgFieldsSelection {
  id?: boolean | boolean;
}

export const includeTagsAvgFields = <T extends TagsAvgFieldsSelection>(
  include: T,
) => include;

export const selectTagsMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TagsMaxFieldsSelection {
  body?: boolean | boolean;
  created_at?: boolean | boolean;
  document_id?: boolean | boolean;
  id?: boolean | boolean;
  locale?: boolean | boolean;
  name?: boolean | boolean;
  published_at?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeTagsMaxFields = <T extends TagsMaxFieldsSelection>(
  include: T,
) => include;

export const selectTagsMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TagsMinFieldsSelection {
  body?: boolean | boolean;
  created_at?: boolean | boolean;
  document_id?: boolean | boolean;
  id?: boolean | boolean;
  locale?: boolean | boolean;
  name?: boolean | boolean;
  published_at?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeTagsMinFields = <T extends TagsMinFieldsSelection>(
  include: T,
) => include;

export const selectTagsMutationResponse = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TagsMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeTagsMutationResponse = <
  T extends TagsMutationResponseSelection,
>(
  include: T,
) => include;

export const selectTagsStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TagsStddevFieldsSelection {
  id?: boolean | boolean;
}

export const includeTagsStddevFields = <T extends TagsStddevFieldsSelection>(
  include: T,
) => include;

export const selectTagsStddevPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TagsStddevPopFieldsSelection {
  id?: boolean | boolean;
}

export const includeTagsStddevPopFields = <
  T extends TagsStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectTagsStddevSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TagsStddevSampFieldsSelection {
  id?: boolean | boolean;
}

export const includeTagsStddevSampFields = <
  T extends TagsStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectTagsSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TagsSumFieldsSelection {
  id?: boolean | boolean;
}

export const includeTagsSumFields = <T extends TagsSumFieldsSelection>(
  include: T,
) => include;

export const selectTagsVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TagsVarPopFieldsSelection {
  id?: boolean | boolean;
}

export const includeTagsVarPopFields = <T extends TagsVarPopFieldsSelection>(
  include: T,
) => include;

export const selectTagsVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TagsVarSampFieldsSelection {
  id?: boolean | boolean;
}

export const includeTagsVarSampFields = <T extends TagsVarSampFieldsSelection>(
  include: T,
) => include;

export const selectTagsVarianceFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface TagsVarianceFieldsSelection {
  id?: boolean | boolean;
}

export const includeTagsVarianceFields = <
  T extends TagsVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectUserMetrics = <T extends FieldSelection<T>>(selection: T) =>
  selection;

export interface UserMetricsSelection {
  achievements?: boolean | boolean;
  best_streak?: boolean | boolean;
  created_at?: boolean | boolean;
  current_level?: boolean | boolean;
  current_streak?: boolean | boolean;
  current_xp?: boolean | boolean;
  downvote_count?: boolean | boolean;
  id?: boolean | boolean;
  interaction_stats?: boolean | boolean;
  last_vote_date?: boolean | boolean;
  multipliers?: boolean | boolean;
  points?: boolean | boolean;
  points_breakdown?: boolean | boolean;
  titles?: boolean | boolean;
  today_vote_count?: boolean | boolean;
  total_reading_time?: boolean | boolean;
  total_votes?: boolean | boolean;
  updated_at?: boolean | boolean;
  upvote_count?: boolean | boolean;
  user_id?: boolean | boolean;
  user_profile?: boolean | boolean;
  vote_accuracy?: boolean | boolean;
  xp_to_next_level?: boolean | boolean;
}

export const includeUserMetrics = <T extends UserMetricsSelection>(
  include: T,
) => include;

export const selectUserMetricsAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserMetricsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: UserMetricsAggregateFieldsSelection;
        include?: UserMetricsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeUserMetricsAggregate = <
  T extends UserMetricsAggregateSelection,
>(
  include: T,
) => include;

export const selectUserMetricsAggregateFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserMetricsAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: UserMetricsAvgFieldsSelection;
        include?: UserMetricsAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: UserMetricsMaxFieldsSelection;
        include?: UserMetricsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: UserMetricsMinFieldsSelection;
        include?: UserMetricsMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: UserMetricsStddevFieldsSelection;
        include?: UserMetricsStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: UserMetricsStddevPopFieldsSelection;
        include?: UserMetricsStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: UserMetricsStddevSampFieldsSelection;
        include?: UserMetricsStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: UserMetricsSumFieldsSelection;
        include?: UserMetricsSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: UserMetricsVarPopFieldsSelection;
        include?: UserMetricsVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: UserMetricsVarSampFieldsSelection;
        include?: UserMetricsVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: UserMetricsVarianceFieldsSelection;
        include?: UserMetricsVarianceFieldsSelection;
      };
}

export const includeUserMetricsAggregateFields = <
  T extends UserMetricsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectUserMetricsAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserMetricsAvgFieldsSelection {
  best_streak?: boolean | boolean;
  current_level?: boolean | boolean;
  current_streak?: boolean | boolean;
  current_xp?: boolean | boolean;
  downvote_count?: boolean | boolean;
  points?: boolean | boolean;
  today_vote_count?: boolean | boolean;
  total_reading_time?: boolean | boolean;
  total_votes?: boolean | boolean;
  upvote_count?: boolean | boolean;
  vote_accuracy?: boolean | boolean;
  xp_to_next_level?: boolean | boolean;
}

export const includeUserMetricsAvgFields = <
  T extends UserMetricsAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectUserMetricsMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserMetricsMaxFieldsSelection {
  best_streak?: boolean | boolean;
  created_at?: boolean | boolean;
  current_level?: boolean | boolean;
  current_streak?: boolean | boolean;
  current_xp?: boolean | boolean;
  downvote_count?: boolean | boolean;
  id?: boolean | boolean;
  last_vote_date?: boolean | boolean;
  points?: boolean | boolean;
  today_vote_count?: boolean | boolean;
  total_reading_time?: boolean | boolean;
  total_votes?: boolean | boolean;
  updated_at?: boolean | boolean;
  upvote_count?: boolean | boolean;
  user_id?: boolean | boolean;
  vote_accuracy?: boolean | boolean;
  xp_to_next_level?: boolean | boolean;
}

export const includeUserMetricsMaxFields = <
  T extends UserMetricsMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectUserMetricsMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserMetricsMinFieldsSelection {
  best_streak?: boolean | boolean;
  created_at?: boolean | boolean;
  current_level?: boolean | boolean;
  current_streak?: boolean | boolean;
  current_xp?: boolean | boolean;
  downvote_count?: boolean | boolean;
  id?: boolean | boolean;
  last_vote_date?: boolean | boolean;
  points?: boolean | boolean;
  today_vote_count?: boolean | boolean;
  total_reading_time?: boolean | boolean;
  total_votes?: boolean | boolean;
  updated_at?: boolean | boolean;
  upvote_count?: boolean | boolean;
  user_id?: boolean | boolean;
  vote_accuracy?: boolean | boolean;
  xp_to_next_level?: boolean | boolean;
}

export const includeUserMetricsMinFields = <
  T extends UserMetricsMinFieldsSelection,
>(
  include: T,
) => include;

export const selectUserMetricsMutationResponse = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserMetricsMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeUserMetricsMutationResponse = <
  T extends UserMetricsMutationResponseSelection,
>(
  include: T,
) => include;

export const selectUserMetricsStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserMetricsStddevFieldsSelection {
  best_streak?: boolean | boolean;
  current_level?: boolean | boolean;
  current_streak?: boolean | boolean;
  current_xp?: boolean | boolean;
  downvote_count?: boolean | boolean;
  points?: boolean | boolean;
  today_vote_count?: boolean | boolean;
  total_reading_time?: boolean | boolean;
  total_votes?: boolean | boolean;
  upvote_count?: boolean | boolean;
  vote_accuracy?: boolean | boolean;
  xp_to_next_level?: boolean | boolean;
}

export const includeUserMetricsStddevFields = <
  T extends UserMetricsStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectUserMetricsStddevPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserMetricsStddevPopFieldsSelection {
  best_streak?: boolean | boolean;
  current_level?: boolean | boolean;
  current_streak?: boolean | boolean;
  current_xp?: boolean | boolean;
  downvote_count?: boolean | boolean;
  points?: boolean | boolean;
  today_vote_count?: boolean | boolean;
  total_reading_time?: boolean | boolean;
  total_votes?: boolean | boolean;
  upvote_count?: boolean | boolean;
  vote_accuracy?: boolean | boolean;
  xp_to_next_level?: boolean | boolean;
}

export const includeUserMetricsStddevPopFields = <
  T extends UserMetricsStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectUserMetricsStddevSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserMetricsStddevSampFieldsSelection {
  best_streak?: boolean | boolean;
  current_level?: boolean | boolean;
  current_streak?: boolean | boolean;
  current_xp?: boolean | boolean;
  downvote_count?: boolean | boolean;
  points?: boolean | boolean;
  today_vote_count?: boolean | boolean;
  total_reading_time?: boolean | boolean;
  total_votes?: boolean | boolean;
  upvote_count?: boolean | boolean;
  vote_accuracy?: boolean | boolean;
  xp_to_next_level?: boolean | boolean;
}

export const includeUserMetricsStddevSampFields = <
  T extends UserMetricsStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectUserMetricsSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserMetricsSumFieldsSelection {
  best_streak?: boolean | boolean;
  current_level?: boolean | boolean;
  current_streak?: boolean | boolean;
  current_xp?: boolean | boolean;
  downvote_count?: boolean | boolean;
  points?: boolean | boolean;
  today_vote_count?: boolean | boolean;
  total_reading_time?: boolean | boolean;
  total_votes?: boolean | boolean;
  upvote_count?: boolean | boolean;
  vote_accuracy?: boolean | boolean;
  xp_to_next_level?: boolean | boolean;
}

export const includeUserMetricsSumFields = <
  T extends UserMetricsSumFieldsSelection,
>(
  include: T,
) => include;

export const selectUserMetricsVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserMetricsVarPopFieldsSelection {
  best_streak?: boolean | boolean;
  current_level?: boolean | boolean;
  current_streak?: boolean | boolean;
  current_xp?: boolean | boolean;
  downvote_count?: boolean | boolean;
  points?: boolean | boolean;
  today_vote_count?: boolean | boolean;
  total_reading_time?: boolean | boolean;
  total_votes?: boolean | boolean;
  upvote_count?: boolean | boolean;
  vote_accuracy?: boolean | boolean;
  xp_to_next_level?: boolean | boolean;
}

export const includeUserMetricsVarPopFields = <
  T extends UserMetricsVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectUserMetricsVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserMetricsVarSampFieldsSelection {
  best_streak?: boolean | boolean;
  current_level?: boolean | boolean;
  current_streak?: boolean | boolean;
  current_xp?: boolean | boolean;
  downvote_count?: boolean | boolean;
  points?: boolean | boolean;
  today_vote_count?: boolean | boolean;
  total_reading_time?: boolean | boolean;
  total_votes?: boolean | boolean;
  upvote_count?: boolean | boolean;
  vote_accuracy?: boolean | boolean;
  xp_to_next_level?: boolean | boolean;
}

export const includeUserMetricsVarSampFields = <
  T extends UserMetricsVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectUserMetricsVarianceFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserMetricsVarianceFieldsSelection {
  best_streak?: boolean | boolean;
  current_level?: boolean | boolean;
  current_streak?: boolean | boolean;
  current_xp?: boolean | boolean;
  downvote_count?: boolean | boolean;
  points?: boolean | boolean;
  today_vote_count?: boolean | boolean;
  total_reading_time?: boolean | boolean;
  total_votes?: boolean | boolean;
  upvote_count?: boolean | boolean;
  vote_accuracy?: boolean | boolean;
  xp_to_next_level?: boolean | boolean;
}

export const includeUserMetricsVarianceFields = <
  T extends UserMetricsVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectUserProfiles = <T extends FieldSelection<T>>(selection: T) =>
  selection;

export interface UserProfilesSelection {
  addresses?: boolean | boolean;
  addresses_aggregate?: boolean | boolean;
  avatar?: boolean | boolean;
  comments?: boolean | boolean;
  comments_aggregate?: boolean | boolean;
  company_employees?: boolean | boolean;
  company_employees_aggregate?: boolean | boolean;
  contacts?: boolean | boolean;
  contacts_aggregate?: boolean | boolean;
  content_source_visits?: boolean | boolean;
  content_source_visits_aggregate?: boolean | boolean;
  created_at?: boolean | boolean;
  customer_payments?: boolean | boolean;
  customer_payments_aggregate?: boolean | boolean;
  customer_subscriptions?: boolean | boolean;
  customer_subscriptions_aggregate?: boolean | boolean;
  dob?: boolean | boolean;
  email?: boolean | boolean;
  feedbacks?: boolean | boolean;
  feedbacks_aggregate?: boolean | boolean;
  feeds?: boolean | boolean;
  feeds_aggregate?: boolean | boolean;
  followed_count?: boolean | boolean;
  followers_count?: boolean | boolean;
  follows?: boolean | boolean;
  follows_aggregate?: boolean | boolean;
  gender_id?: boolean | boolean;
  given_name?: boolean | boolean;
  id?: boolean | boolean;
  introduction?: boolean | boolean;
  is_active?: boolean | boolean;
  last_seen?: boolean | boolean;
  plan?: boolean | boolean;
  role?: boolean | boolean;
  surname?: boolean | boolean;
  updated_at?: boolean | boolean;
  user_metric?:
    | boolean
    | {
        select?: UserMetricsSelection;
        include?: UserMetricsSelection;
      };
  username?: boolean | boolean;
}

export const includeUserProfiles = <T extends UserProfilesSelection>(
  include: T,
) => include;

export const selectUserProfilesAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserProfilesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: UserProfilesAggregateFieldsSelection;
        include?: UserProfilesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeUserProfilesAggregate = <
  T extends UserProfilesAggregateSelection,
>(
  include: T,
) => include;

export const selectUserProfilesAggregateFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserProfilesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: UserProfilesAvgFieldsSelection;
        include?: UserProfilesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: UserProfilesMaxFieldsSelection;
        include?: UserProfilesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: UserProfilesMinFieldsSelection;
        include?: UserProfilesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: UserProfilesStddevFieldsSelection;
        include?: UserProfilesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: UserProfilesStddevPopFieldsSelection;
        include?: UserProfilesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: UserProfilesStddevSampFieldsSelection;
        include?: UserProfilesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: UserProfilesSumFieldsSelection;
        include?: UserProfilesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: UserProfilesVarPopFieldsSelection;
        include?: UserProfilesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: UserProfilesVarSampFieldsSelection;
        include?: UserProfilesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: UserProfilesVarianceFieldsSelection;
        include?: UserProfilesVarianceFieldsSelection;
      };
}

export const includeUserProfilesAggregateFields = <
  T extends UserProfilesAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectUserProfilesAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserProfilesAvgFieldsSelection {
  followed_count?: boolean | boolean;
  followers_count?: boolean | boolean;
  gender_id?: boolean | boolean;
}

export const includeUserProfilesAvgFields = <
  T extends UserProfilesAvgFieldsSelection,
>(
  include: T,
) => include;

export const selectUserProfilesMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserProfilesMaxFieldsSelection {
  avatar?: boolean | boolean;
  created_at?: boolean | boolean;
  dob?: boolean | boolean;
  email?: boolean | boolean;
  followed_count?: boolean | boolean;
  followers_count?: boolean | boolean;
  gender_id?: boolean | boolean;
  given_name?: boolean | boolean;
  id?: boolean | boolean;
  introduction?: boolean | boolean;
  last_seen?: boolean | boolean;
  plan?: boolean | boolean;
  role?: boolean | boolean;
  surname?: boolean | boolean;
  updated_at?: boolean | boolean;
  username?: boolean | boolean;
}

export const includeUserProfilesMaxFields = <
  T extends UserProfilesMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectUserProfilesMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserProfilesMinFieldsSelection {
  avatar?: boolean | boolean;
  created_at?: boolean | boolean;
  dob?: boolean | boolean;
  email?: boolean | boolean;
  followed_count?: boolean | boolean;
  followers_count?: boolean | boolean;
  gender_id?: boolean | boolean;
  given_name?: boolean | boolean;
  id?: boolean | boolean;
  introduction?: boolean | boolean;
  last_seen?: boolean | boolean;
  plan?: boolean | boolean;
  role?: boolean | boolean;
  surname?: boolean | boolean;
  updated_at?: boolean | boolean;
  username?: boolean | boolean;
}

export const includeUserProfilesMinFields = <
  T extends UserProfilesMinFieldsSelection,
>(
  include: T,
) => include;

export const selectUserProfilesMutationResponse = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserProfilesMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeUserProfilesMutationResponse = <
  T extends UserProfilesMutationResponseSelection,
>(
  include: T,
) => include;

export const selectUserProfilesStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserProfilesStddevFieldsSelection {
  followed_count?: boolean | boolean;
  followers_count?: boolean | boolean;
  gender_id?: boolean | boolean;
}

export const includeUserProfilesStddevFields = <
  T extends UserProfilesStddevFieldsSelection,
>(
  include: T,
) => include;

export const selectUserProfilesStddevPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserProfilesStddevPopFieldsSelection {
  followed_count?: boolean | boolean;
  followers_count?: boolean | boolean;
  gender_id?: boolean | boolean;
}

export const includeUserProfilesStddevPopFields = <
  T extends UserProfilesStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectUserProfilesStddevSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserProfilesStddevSampFieldsSelection {
  followed_count?: boolean | boolean;
  followers_count?: boolean | boolean;
  gender_id?: boolean | boolean;
}

export const includeUserProfilesStddevSampFields = <
  T extends UserProfilesStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectUserProfilesSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserProfilesSumFieldsSelection {
  followed_count?: boolean | boolean;
  followers_count?: boolean | boolean;
  gender_id?: boolean | boolean;
}

export const includeUserProfilesSumFields = <
  T extends UserProfilesSumFieldsSelection,
>(
  include: T,
) => include;

export const selectUserProfilesVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserProfilesVarPopFieldsSelection {
  followed_count?: boolean | boolean;
  followers_count?: boolean | boolean;
  gender_id?: boolean | boolean;
}

export const includeUserProfilesVarPopFields = <
  T extends UserProfilesVarPopFieldsSelection,
>(
  include: T,
) => include;

export const selectUserProfilesVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserProfilesVarSampFieldsSelection {
  followed_count?: boolean | boolean;
  followers_count?: boolean | boolean;
  gender_id?: boolean | boolean;
}

export const includeUserProfilesVarSampFields = <
  T extends UserProfilesVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectUserProfilesVarianceFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface UserProfilesVarianceFieldsSelection {
  followed_count?: boolean | boolean;
  followers_count?: boolean | boolean;
  gender_id?: boolean | boolean;
}

export const includeUserProfilesVarianceFields = <
  T extends UserProfilesVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectVotes = <T extends FieldSelection<T>>(selection: T) =>
  selection;

export interface VotesSelection {
  content_id?: boolean | boolean;
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  user_id?: boolean | boolean;
  vote_type?: boolean | boolean;
}

export const includeVotes = <T extends VotesSelection>(include: T) => include;

export const selectVotesAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface VotesAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: VotesAggregateFieldsSelection;
        include?: VotesAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeVotesAggregate = <T extends VotesAggregateSelection>(
  include: T,
) => include;

export const selectVotesAggregateFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface VotesAggregateFieldsSelection {
  avg?:
    | boolean
    | {
        select?: VotesAvgFieldsSelection;
        include?: VotesAvgFieldsSelection;
      };
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: VotesMaxFieldsSelection;
        include?: VotesMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: VotesMinFieldsSelection;
        include?: VotesMinFieldsSelection;
      };
  stddev?:
    | boolean
    | {
        select?: VotesStddevFieldsSelection;
        include?: VotesStddevFieldsSelection;
      };
  stddev_pop?:
    | boolean
    | {
        select?: VotesStddevPopFieldsSelection;
        include?: VotesStddevPopFieldsSelection;
      };
  stddev_samp?:
    | boolean
    | {
        select?: VotesStddevSampFieldsSelection;
        include?: VotesStddevSampFieldsSelection;
      };
  sum?:
    | boolean
    | {
        select?: VotesSumFieldsSelection;
        include?: VotesSumFieldsSelection;
      };
  var_pop?:
    | boolean
    | {
        select?: VotesVarPopFieldsSelection;
        include?: VotesVarPopFieldsSelection;
      };
  var_samp?:
    | boolean
    | {
        select?: VotesVarSampFieldsSelection;
        include?: VotesVarSampFieldsSelection;
      };
  variance?:
    | boolean
    | {
        select?: VotesVarianceFieldsSelection;
        include?: VotesVarianceFieldsSelection;
      };
}

export const includeVotesAggregateFields = <
  T extends VotesAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectVotesAvgFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface VotesAvgFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeVotesAvgFields = <T extends VotesAvgFieldsSelection>(
  include: T,
) => include;

export const selectVotesMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface VotesMaxFieldsSelection {
  content_id?: boolean | boolean;
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  user_id?: boolean | boolean;
  vote_type?: boolean | boolean;
}

export const includeVotesMaxFields = <T extends VotesMaxFieldsSelection>(
  include: T,
) => include;

export const selectVotesMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface VotesMinFieldsSelection {
  content_id?: boolean | boolean;
  content_type?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  user_id?: boolean | boolean;
  vote_type?: boolean | boolean;
}

export const includeVotesMinFields = <T extends VotesMinFieldsSelection>(
  include: T,
) => include;

export const selectVotesMutationResponse = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface VotesMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeVotesMutationResponse = <
  T extends VotesMutationResponseSelection,
>(
  include: T,
) => include;

export const selectVotesStddevFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface VotesStddevFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeVotesStddevFields = <T extends VotesStddevFieldsSelection>(
  include: T,
) => include;

export const selectVotesStddevPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface VotesStddevPopFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeVotesStddevPopFields = <
  T extends VotesStddevPopFieldsSelection,
>(
  include: T,
) => include;

export const selectVotesStddevSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface VotesStddevSampFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeVotesStddevSampFields = <
  T extends VotesStddevSampFieldsSelection,
>(
  include: T,
) => include;

export const selectVotesSumFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface VotesSumFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeVotesSumFields = <T extends VotesSumFieldsSelection>(
  include: T,
) => include;

export const selectVotesVarPopFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface VotesVarPopFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeVotesVarPopFields = <T extends VotesVarPopFieldsSelection>(
  include: T,
) => include;

export const selectVotesVarSampFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface VotesVarSampFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeVotesVarSampFields = <
  T extends VotesVarSampFieldsSelection,
>(
  include: T,
) => include;

export const selectVotesVarianceFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface VotesVarianceFieldsSelection {
  vote_type?: boolean | boolean;
}

export const includeVotesVarianceFields = <
  T extends VotesVarianceFieldsSelection,
>(
  include: T,
) => include;

export const selectWorkflows = <T extends FieldSelection<T>>(selection: T) =>
  selection;

export interface WorkflowsSelection {
  completed_at?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  metadata?: boolean | boolean;
  name?: boolean | boolean;
  started_at?: boolean | boolean;
  status?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeWorkflows = <T extends WorkflowsSelection>(include: T) =>
  include;

export const selectWorkflowsAggregate = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface WorkflowsAggregateSelection {
  aggregate?:
    | boolean
    | {
        select?: WorkflowsAggregateFieldsSelection;
        include?: WorkflowsAggregateFieldsSelection;
      };
  nodes?: boolean | boolean;
}

export const includeWorkflowsAggregate = <
  T extends WorkflowsAggregateSelection,
>(
  include: T,
) => include;

export const selectWorkflowsAggregateFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface WorkflowsAggregateFieldsSelection {
  count?: boolean | boolean;
  max?:
    | boolean
    | {
        select?: WorkflowsMaxFieldsSelection;
        include?: WorkflowsMaxFieldsSelection;
      };
  min?:
    | boolean
    | {
        select?: WorkflowsMinFieldsSelection;
        include?: WorkflowsMinFieldsSelection;
      };
}

export const includeWorkflowsAggregateFields = <
  T extends WorkflowsAggregateFieldsSelection,
>(
  include: T,
) => include;

export const selectWorkflowsMaxFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface WorkflowsMaxFieldsSelection {
  completed_at?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  started_at?: boolean | boolean;
  status?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeWorkflowsMaxFields = <
  T extends WorkflowsMaxFieldsSelection,
>(
  include: T,
) => include;

export const selectWorkflowsMinFields = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface WorkflowsMinFieldsSelection {
  completed_at?: boolean | boolean;
  created_at?: boolean | boolean;
  id?: boolean | boolean;
  name?: boolean | boolean;
  started_at?: boolean | boolean;
  status?: boolean | boolean;
  updated_at?: boolean | boolean;
}

export const includeWorkflowsMinFields = <
  T extends WorkflowsMinFieldsSelection,
>(
  include: T,
) => include;

export const selectWorkflowsMutationResponse = <T extends FieldSelection<T>>(
  selection: T,
) => selection;

export interface WorkflowsMutationResponseSelection {
  affected_rows?: boolean | boolean;
  returning?: boolean | boolean;
}

export const includeWorkflowsMutationResponse = <
  T extends WorkflowsMutationResponseSelection,
>(
  include: T,
) => include;

export class AdDailyMetricsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdDailyMetrics> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdDailyMetrics, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdDailyMetrics = () => new AdDailyMetricsQueryBuilder();

export class AdDailyMetricsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdDailyMetricsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdDailyMetricsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdDailyMetricsAggregate = () =>
  new AdDailyMetricsAggregateQueryBuilder();

export class AdDailyMetricsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdDailyMetricsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdDailyMetricsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdDailyMetricsAggregateFields = () =>
  new AdDailyMetricsAggregateFieldsQueryBuilder();

export class AdDailyMetricsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdDailyMetricsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdDailyMetricsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdDailyMetricsAvgFields = () =>
  new AdDailyMetricsAvgFieldsQueryBuilder();

export class AdDailyMetricsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdDailyMetricsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdDailyMetricsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdDailyMetricsMaxFields = () =>
  new AdDailyMetricsMaxFieldsQueryBuilder();

export class AdDailyMetricsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdDailyMetricsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdDailyMetricsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdDailyMetricsMinFields = () =>
  new AdDailyMetricsMinFieldsQueryBuilder();

export class AdDailyMetricsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdDailyMetricsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdDailyMetricsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdDailyMetricsMutationResponse = () =>
  new AdDailyMetricsMutationResponseQueryBuilder();

export class AdDailyMetricsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdDailyMetricsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdDailyMetricsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdDailyMetricsStddevFields = () =>
  new AdDailyMetricsStddevFieldsQueryBuilder();

export class AdDailyMetricsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdDailyMetricsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdDailyMetricsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdDailyMetricsStddevPopFields = () =>
  new AdDailyMetricsStddevPopFieldsQueryBuilder();

export class AdDailyMetricsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdDailyMetricsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdDailyMetricsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdDailyMetricsStddevSampFields = () =>
  new AdDailyMetricsStddevSampFieldsQueryBuilder();

export class AdDailyMetricsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdDailyMetricsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdDailyMetricsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdDailyMetricsSumFields = () =>
  new AdDailyMetricsSumFieldsQueryBuilder();

export class AdDailyMetricsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdDailyMetricsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdDailyMetricsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdDailyMetricsVarPopFields = () =>
  new AdDailyMetricsVarPopFieldsQueryBuilder();

export class AdDailyMetricsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdDailyMetricsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdDailyMetricsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdDailyMetricsVarSampFields = () =>
  new AdDailyMetricsVarSampFieldsQueryBuilder();

export class AdDailyMetricsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdDailyMetricsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdDailyMetricsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdDailyMetricsVarianceFields = () =>
  new AdDailyMetricsVarianceFieldsQueryBuilder();

export class AdPackagesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdPackages> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdPackages, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdPackages = () => new AdPackagesQueryBuilder();

export class AdPackagesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdPackagesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdPackagesAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdPackagesAggregate = () =>
  new AdPackagesAggregateQueryBuilder();

export class AdPackagesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdPackagesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdPackagesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdPackagesAggregateFields = () =>
  new AdPackagesAggregateFieldsQueryBuilder();

export class AdPackagesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdPackagesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdPackagesAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdPackagesAvgFields = () =>
  new AdPackagesAvgFieldsQueryBuilder();

export class AdPackagesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdPackagesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdPackagesMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdPackagesMaxFields = () =>
  new AdPackagesMaxFieldsQueryBuilder();

export class AdPackagesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdPackagesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdPackagesMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdPackagesMinFields = () =>
  new AdPackagesMinFieldsQueryBuilder();

export class AdPackagesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdPackagesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdPackagesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdPackagesMutationResponse = () =>
  new AdPackagesMutationResponseQueryBuilder();

export class AdPackagesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdPackagesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdPackagesStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdPackagesStddevFields = () =>
  new AdPackagesStddevFieldsQueryBuilder();

export class AdPackagesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdPackagesStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdPackagesStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdPackagesStddevPopFields = () =>
  new AdPackagesStddevPopFieldsQueryBuilder();

export class AdPackagesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdPackagesStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdPackagesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdPackagesStddevSampFields = () =>
  new AdPackagesStddevSampFieldsQueryBuilder();

export class AdPackagesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdPackagesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdPackagesSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdPackagesSumFields = () =>
  new AdPackagesSumFieldsQueryBuilder();

export class AdPackagesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdPackagesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdPackagesVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdPackagesVarPopFields = () =>
  new AdPackagesVarPopFieldsQueryBuilder();

export class AdPackagesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdPackagesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdPackagesVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdPackagesVarSampFields = () =>
  new AdPackagesVarSampFieldsQueryBuilder();

export class AdPackagesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdPackagesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdPackagesVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdPackagesVarianceFields = () =>
  new AdPackagesVarianceFieldsQueryBuilder();

export class AdVariantsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdVariants> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdVariants, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdVariants = () => new AdVariantsQueryBuilder();

export class AdVariantsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdVariantsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdVariantsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdVariantsAggregate = () =>
  new AdVariantsAggregateQueryBuilder();

export class AdVariantsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdVariantsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdVariantsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdVariantsAggregateFields = () =>
  new AdVariantsAggregateFieldsQueryBuilder();

export class AdVariantsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdVariantsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdVariantsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdVariantsMaxFields = () =>
  new AdVariantsMaxFieldsQueryBuilder();

export class AdVariantsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdVariantsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdVariantsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdVariantsMinFields = () =>
  new AdVariantsMinFieldsQueryBuilder();

export class AdVariantsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdVariantsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AdVariantsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdVariantsMutationResponse = () =>
  new AdVariantsMutationResponseQueryBuilder();

export class AddressesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Addresses> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Addresses, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAddresses = () => new AddressesQueryBuilder();

export class AddressesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AddressesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AddressesAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAddressesAggregate = () =>
  new AddressesAggregateQueryBuilder();

export class AddressesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AddressesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AddressesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAddressesAggregateFields = () =>
  new AddressesAggregateFieldsQueryBuilder();

export class AddressesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AddressesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AddressesAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAddressesAvgFields = () =>
  new AddressesAvgFieldsQueryBuilder();

export class AddressesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AddressesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AddressesMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAddressesMaxFields = () =>
  new AddressesMaxFieldsQueryBuilder();

export class AddressesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AddressesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AddressesMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAddressesMinFields = () =>
  new AddressesMinFieldsQueryBuilder();

export class AddressesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AddressesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AddressesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAddressesMutationResponse = () =>
  new AddressesMutationResponseQueryBuilder();

export class AddressesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AddressesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AddressesStddevFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAddressesStddevFields = () =>
  new AddressesStddevFieldsQueryBuilder();

export class AddressesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AddressesStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AddressesStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAddressesStddevPopFields = () =>
  new AddressesStddevPopFieldsQueryBuilder();

export class AddressesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AddressesStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AddressesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAddressesStddevSampFields = () =>
  new AddressesStddevSampFieldsQueryBuilder();

export class AddressesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AddressesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AddressesSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAddressesSumFields = () =>
  new AddressesSumFieldsQueryBuilder();

export class AddressesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AddressesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AddressesVarPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAddressesVarPopFields = () =>
  new AddressesVarPopFieldsQueryBuilder();

export class AddressesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AddressesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AddressesVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAddressesVarSampFields = () =>
  new AddressesVarSampFieldsQueryBuilder();

export class AddressesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AddressesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.AddressesVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAddressesVarianceFields = () =>
  new AddressesVarianceFieldsQueryBuilder();

export class AdsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Ads> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Ads, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAds = () => new AdsQueryBuilder();

export class AdsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdsAggregate = () => new AdsAggregateQueryBuilder();

export class AdsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdsAggregateFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdsAggregateFields = () =>
  new AdsAggregateFieldsQueryBuilder();

export class AdsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdsMaxFields = () => new AdsMaxFieldsQueryBuilder();

export class AdsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdsMinFields = () => new AdsMinFieldsQueryBuilder();

export class AdsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.AdsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.AdsMutationResponse, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryAdsMutationResponse = () =>
  new AdsMutationResponseQueryBuilder();

export class BlacklistedDomainsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedDomains> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.BlacklistedDomains, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedDomains = () =>
  new BlacklistedDomainsQueryBuilder();

export class BlacklistedDomainsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedDomainsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedDomainsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedDomainsAggregate = () =>
  new BlacklistedDomainsAggregateQueryBuilder();

export class BlacklistedDomainsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedDomainsAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedDomainsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedDomainsAggregateFields = () =>
  new BlacklistedDomainsAggregateFieldsQueryBuilder();

export class BlacklistedDomainsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedDomainsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedDomainsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedDomainsMaxFields = () =>
  new BlacklistedDomainsMaxFieldsQueryBuilder();

export class BlacklistedDomainsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedDomainsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedDomainsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedDomainsMinFields = () =>
  new BlacklistedDomainsMinFieldsQueryBuilder();

export class BlacklistedDomainsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedDomainsMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedDomainsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedDomainsMutationResponse = () =>
  new BlacklistedDomainsMutationResponseQueryBuilder();

export class BlacklistedUrlsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedUrls> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.BlacklistedUrls, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedUrls = () => new BlacklistedUrlsQueryBuilder();

export class BlacklistedUrlsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedUrlsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedUrlsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedUrlsAggregate = () =>
  new BlacklistedUrlsAggregateQueryBuilder();

export class BlacklistedUrlsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedUrlsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedUrlsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedUrlsAggregateFields = () =>
  new BlacklistedUrlsAggregateFieldsQueryBuilder();

export class BlacklistedUrlsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedUrlsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedUrlsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedUrlsAvgFields = () =>
  new BlacklistedUrlsAvgFieldsQueryBuilder();

export class BlacklistedUrlsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedUrlsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedUrlsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedUrlsMaxFields = () =>
  new BlacklistedUrlsMaxFieldsQueryBuilder();

export class BlacklistedUrlsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedUrlsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedUrlsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedUrlsMinFields = () =>
  new BlacklistedUrlsMinFieldsQueryBuilder();

export class BlacklistedUrlsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedUrlsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedUrlsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedUrlsMutationResponse = () =>
  new BlacklistedUrlsMutationResponseQueryBuilder();

export class BlacklistedUrlsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedUrlsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedUrlsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedUrlsStddevFields = () =>
  new BlacklistedUrlsStddevFieldsQueryBuilder();

export class BlacklistedUrlsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedUrlsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedUrlsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedUrlsStddevPopFields = () =>
  new BlacklistedUrlsStddevPopFieldsQueryBuilder();

export class BlacklistedUrlsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedUrlsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedUrlsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedUrlsStddevSampFields = () =>
  new BlacklistedUrlsStddevSampFieldsQueryBuilder();

export class BlacklistedUrlsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedUrlsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedUrlsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedUrlsSumFields = () =>
  new BlacklistedUrlsSumFieldsQueryBuilder();

export class BlacklistedUrlsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedUrlsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedUrlsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedUrlsVarPopFields = () =>
  new BlacklistedUrlsVarPopFieldsQueryBuilder();

export class BlacklistedUrlsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedUrlsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedUrlsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedUrlsVarSampFields = () =>
  new BlacklistedUrlsVarSampFieldsQueryBuilder();

export class BlacklistedUrlsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlacklistedUrlsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlacklistedUrlsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlacklistedUrlsVarianceFields = () =>
  new BlacklistedUrlsVarianceFieldsQueryBuilder();

export class BlockedIpsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlockedIps> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.BlockedIps, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlockedIps = () => new BlockedIpsQueryBuilder();

export class BlockedIpsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlockedIpsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.BlockedIpsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlockedIpsAggregate = () =>
  new BlockedIpsAggregateQueryBuilder();

export class BlockedIpsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlockedIpsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlockedIpsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlockedIpsAggregateFields = () =>
  new BlockedIpsAggregateFieldsQueryBuilder();

export class BlockedIpsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlockedIpsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.BlockedIpsAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlockedIpsAvgFields = () =>
  new BlockedIpsAvgFieldsQueryBuilder();

export class BlockedIpsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlockedIpsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.BlockedIpsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlockedIpsMaxFields = () =>
  new BlockedIpsMaxFieldsQueryBuilder();

export class BlockedIpsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlockedIpsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.BlockedIpsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlockedIpsMinFields = () =>
  new BlockedIpsMinFieldsQueryBuilder();

export class BlockedIpsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlockedIpsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlockedIpsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlockedIpsMutationResponse = () =>
  new BlockedIpsMutationResponseQueryBuilder();

export class BlockedIpsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlockedIpsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlockedIpsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlockedIpsStddevFields = () =>
  new BlockedIpsStddevFieldsQueryBuilder();

export class BlockedIpsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlockedIpsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlockedIpsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlockedIpsStddevPopFields = () =>
  new BlockedIpsStddevPopFieldsQueryBuilder();

export class BlockedIpsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlockedIpsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlockedIpsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlockedIpsStddevSampFields = () =>
  new BlockedIpsStddevSampFieldsQueryBuilder();

export class BlockedIpsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlockedIpsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.BlockedIpsSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlockedIpsSumFields = () =>
  new BlockedIpsSumFieldsQueryBuilder();

export class BlockedIpsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlockedIpsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlockedIpsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlockedIpsVarPopFields = () =>
  new BlockedIpsVarPopFieldsQueryBuilder();

export class BlockedIpsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlockedIpsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlockedIpsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlockedIpsVarSampFields = () =>
  new BlockedIpsVarSampFieldsQueryBuilder();

export class BlockedIpsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BlockedIpsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BlockedIpsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBlockedIpsVarianceFields = () =>
  new BlockedIpsVarianceFieldsQueryBuilder();

export class BookmarkFoldersQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarkFolders> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.BookmarkFolders, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarkFolders = () => new BookmarkFoldersQueryBuilder();

export class BookmarkFoldersAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarkFoldersAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BookmarkFoldersAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarkFoldersAggregate = () =>
  new BookmarkFoldersAggregateQueryBuilder();

export class BookmarkFoldersAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarkFoldersAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BookmarkFoldersAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarkFoldersAggregateFields = () =>
  new BookmarkFoldersAggregateFieldsQueryBuilder();

export class BookmarkFoldersAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarkFoldersAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BookmarkFoldersAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarkFoldersAvgFields = () =>
  new BookmarkFoldersAvgFieldsQueryBuilder();

export class BookmarkFoldersMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarkFoldersMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BookmarkFoldersMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarkFoldersMaxFields = () =>
  new BookmarkFoldersMaxFieldsQueryBuilder();

export class BookmarkFoldersMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarkFoldersMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BookmarkFoldersMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarkFoldersMinFields = () =>
  new BookmarkFoldersMinFieldsQueryBuilder();

export class BookmarkFoldersMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarkFoldersMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BookmarkFoldersMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarkFoldersMutationResponse = () =>
  new BookmarkFoldersMutationResponseQueryBuilder();

export class BookmarkFoldersStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarkFoldersStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BookmarkFoldersStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarkFoldersStddevFields = () =>
  new BookmarkFoldersStddevFieldsQueryBuilder();

export class BookmarkFoldersStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarkFoldersStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BookmarkFoldersStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarkFoldersStddevPopFields = () =>
  new BookmarkFoldersStddevPopFieldsQueryBuilder();

export class BookmarkFoldersStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarkFoldersStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BookmarkFoldersStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarkFoldersStddevSampFields = () =>
  new BookmarkFoldersStddevSampFieldsQueryBuilder();

export class BookmarkFoldersSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarkFoldersSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BookmarkFoldersSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarkFoldersSumFields = () =>
  new BookmarkFoldersSumFieldsQueryBuilder();

export class BookmarkFoldersVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarkFoldersVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BookmarkFoldersVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarkFoldersVarPopFields = () =>
  new BookmarkFoldersVarPopFieldsQueryBuilder();

export class BookmarkFoldersVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarkFoldersVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BookmarkFoldersVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarkFoldersVarSampFields = () =>
  new BookmarkFoldersVarSampFieldsQueryBuilder();

export class BookmarkFoldersVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarkFoldersVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BookmarkFoldersVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarkFoldersVarianceFields = () =>
  new BookmarkFoldersVarianceFieldsQueryBuilder();

export class BookmarksQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Bookmarks> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Bookmarks, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarks = () => new BookmarksQueryBuilder();

export class BookmarksAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarksAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.BookmarksAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarksAggregate = () =>
  new BookmarksAggregateQueryBuilder();

export class BookmarksAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarksAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BookmarksAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarksAggregateFields = () =>
  new BookmarksAggregateFieldsQueryBuilder();

export class BookmarksMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarksMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.BookmarksMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarksMaxFields = () =>
  new BookmarksMaxFieldsQueryBuilder();

export class BookmarksMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarksMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.BookmarksMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarksMinFields = () =>
  new BookmarksMinFieldsQueryBuilder();

export class BookmarksMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BookmarksMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BookmarksMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBookmarksMutationResponse = () =>
  new BookmarksMutationResponseQueryBuilder();

export class BusinessDomainsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BusinessDomains> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.BusinessDomains, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBusinessDomains = () => new BusinessDomainsQueryBuilder();

export class BusinessDomainsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BusinessDomainsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BusinessDomainsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBusinessDomainsAggregate = () =>
  new BusinessDomainsAggregateQueryBuilder();

export class BusinessDomainsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BusinessDomainsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BusinessDomainsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBusinessDomainsAggregateFields = () =>
  new BusinessDomainsAggregateFieldsQueryBuilder();

export class BusinessDomainsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BusinessDomainsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BusinessDomainsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBusinessDomainsMaxFields = () =>
  new BusinessDomainsMaxFieldsQueryBuilder();

export class BusinessDomainsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BusinessDomainsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BusinessDomainsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBusinessDomainsMinFields = () =>
  new BusinessDomainsMinFieldsQueryBuilder();

export class BusinessDomainsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.BusinessDomainsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.BusinessDomainsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryBusinessDomainsMutationResponse = () =>
  new BusinessDomainsMutationResponseQueryBuilder();

export class CategoriesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Categories> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Categories, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategories = () => new CategoriesQueryBuilder();

export class CategoriesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategoriesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CategoriesAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategoriesAggregate = () =>
  new CategoriesAggregateQueryBuilder();

export class CategoriesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategoriesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategoriesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategoriesAggregateFields = () =>
  new CategoriesAggregateFieldsQueryBuilder();

export class CategoriesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategoriesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CategoriesAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategoriesAvgFields = () =>
  new CategoriesAvgFieldsQueryBuilder();

export class CategoriesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategoriesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CategoriesMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategoriesMaxFields = () =>
  new CategoriesMaxFieldsQueryBuilder();

export class CategoriesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategoriesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CategoriesMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategoriesMinFields = () =>
  new CategoriesMinFieldsQueryBuilder();

export class CategoriesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategoriesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategoriesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategoriesMutationResponse = () =>
  new CategoriesMutationResponseQueryBuilder();

export class CategoriesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategoriesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategoriesStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategoriesStddevFields = () =>
  new CategoriesStddevFieldsQueryBuilder();

export class CategoriesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategoriesStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategoriesStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategoriesStddevPopFields = () =>
  new CategoriesStddevPopFieldsQueryBuilder();

export class CategoriesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategoriesStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategoriesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategoriesStddevSampFields = () =>
  new CategoriesStddevSampFieldsQueryBuilder();

export class CategoriesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategoriesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CategoriesSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategoriesSumFields = () =>
  new CategoriesSumFieldsQueryBuilder();

export class CategoriesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategoriesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategoriesVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategoriesVarPopFields = () =>
  new CategoriesVarPopFieldsQueryBuilder();

export class CategoriesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategoriesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategoriesVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategoriesVarSampFields = () =>
  new CategoriesVarSampFieldsQueryBuilder();

export class CategoriesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategoriesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategoriesVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategoriesVarianceFields = () =>
  new CategoriesVarianceFieldsQueryBuilder();

export class CategorizedUrlsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategorizedUrls> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CategorizedUrls, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategorizedUrls = () => new CategorizedUrlsQueryBuilder();

export class CategorizedUrlsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategorizedUrlsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategorizedUrlsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategorizedUrlsAggregate = () =>
  new CategorizedUrlsAggregateQueryBuilder();

export class CategorizedUrlsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategorizedUrlsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategorizedUrlsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategorizedUrlsAggregateFields = () =>
  new CategorizedUrlsAggregateFieldsQueryBuilder();

export class CategorizedUrlsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategorizedUrlsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategorizedUrlsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategorizedUrlsAvgFields = () =>
  new CategorizedUrlsAvgFieldsQueryBuilder();

export class CategorizedUrlsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategorizedUrlsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategorizedUrlsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategorizedUrlsMaxFields = () =>
  new CategorizedUrlsMaxFieldsQueryBuilder();

export class CategorizedUrlsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategorizedUrlsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategorizedUrlsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategorizedUrlsMinFields = () =>
  new CategorizedUrlsMinFieldsQueryBuilder();

export class CategorizedUrlsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategorizedUrlsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategorizedUrlsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategorizedUrlsMutationResponse = () =>
  new CategorizedUrlsMutationResponseQueryBuilder();

export class CategorizedUrlsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategorizedUrlsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategorizedUrlsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategorizedUrlsStddevFields = () =>
  new CategorizedUrlsStddevFieldsQueryBuilder();

export class CategorizedUrlsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategorizedUrlsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategorizedUrlsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategorizedUrlsStddevPopFields = () =>
  new CategorizedUrlsStddevPopFieldsQueryBuilder();

export class CategorizedUrlsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategorizedUrlsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategorizedUrlsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategorizedUrlsStddevSampFields = () =>
  new CategorizedUrlsStddevSampFieldsQueryBuilder();

export class CategorizedUrlsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategorizedUrlsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategorizedUrlsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategorizedUrlsSumFields = () =>
  new CategorizedUrlsSumFieldsQueryBuilder();

export class CategorizedUrlsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategorizedUrlsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategorizedUrlsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategorizedUrlsVarPopFields = () =>
  new CategorizedUrlsVarPopFieldsQueryBuilder();

export class CategorizedUrlsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategorizedUrlsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategorizedUrlsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategorizedUrlsVarSampFields = () =>
  new CategorizedUrlsVarSampFieldsQueryBuilder();

export class CategorizedUrlsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CategorizedUrlsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CategorizedUrlsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCategorizedUrlsVarianceFields = () =>
  new CategorizedUrlsVarianceFieldsQueryBuilder();

export class CircuitBreakerStatesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CircuitBreakerStates> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CircuitBreakerStates, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCircuitBreakerStates = () =>
  new CircuitBreakerStatesQueryBuilder();

export class CircuitBreakerStatesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CircuitBreakerStatesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CircuitBreakerStatesAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCircuitBreakerStatesAggregate = () =>
  new CircuitBreakerStatesAggregateQueryBuilder();

export class CircuitBreakerStatesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CircuitBreakerStatesAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CircuitBreakerStatesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCircuitBreakerStatesAggregateFields = () =>
  new CircuitBreakerStatesAggregateFieldsQueryBuilder();

export class CircuitBreakerStatesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CircuitBreakerStatesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CircuitBreakerStatesAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCircuitBreakerStatesAvgFields = () =>
  new CircuitBreakerStatesAvgFieldsQueryBuilder();

export class CircuitBreakerStatesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CircuitBreakerStatesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CircuitBreakerStatesMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCircuitBreakerStatesMaxFields = () =>
  new CircuitBreakerStatesMaxFieldsQueryBuilder();

export class CircuitBreakerStatesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CircuitBreakerStatesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CircuitBreakerStatesMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCircuitBreakerStatesMinFields = () =>
  new CircuitBreakerStatesMinFieldsQueryBuilder();

export class CircuitBreakerStatesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CircuitBreakerStatesMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CircuitBreakerStatesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCircuitBreakerStatesMutationResponse = () =>
  new CircuitBreakerStatesMutationResponseQueryBuilder();

export class CircuitBreakerStatesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CircuitBreakerStatesStddevFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CircuitBreakerStatesStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCircuitBreakerStatesStddevFields = () =>
  new CircuitBreakerStatesStddevFieldsQueryBuilder();

export class CircuitBreakerStatesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CircuitBreakerStatesStddevPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CircuitBreakerStatesStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCircuitBreakerStatesStddevPopFields = () =>
  new CircuitBreakerStatesStddevPopFieldsQueryBuilder();

export class CircuitBreakerStatesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CircuitBreakerStatesStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CircuitBreakerStatesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCircuitBreakerStatesStddevSampFields = () =>
  new CircuitBreakerStatesStddevSampFieldsQueryBuilder();

export class CircuitBreakerStatesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CircuitBreakerStatesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CircuitBreakerStatesSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCircuitBreakerStatesSumFields = () =>
  new CircuitBreakerStatesSumFieldsQueryBuilder();

export class CircuitBreakerStatesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CircuitBreakerStatesVarPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CircuitBreakerStatesVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCircuitBreakerStatesVarPopFields = () =>
  new CircuitBreakerStatesVarPopFieldsQueryBuilder();

export class CircuitBreakerStatesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CircuitBreakerStatesVarSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CircuitBreakerStatesVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCircuitBreakerStatesVarSampFields = () =>
  new CircuitBreakerStatesVarSampFieldsQueryBuilder();

export class CircuitBreakerStatesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CircuitBreakerStatesVarianceFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CircuitBreakerStatesVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCircuitBreakerStatesVarianceFields = () =>
  new CircuitBreakerStatesVarianceFieldsQueryBuilder();

export class CitiesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Cities> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Cities, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCities = () => new CitiesQueryBuilder();

export class CitiesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CitiesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CitiesAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCitiesAggregate = () => new CitiesAggregateQueryBuilder();

export class CitiesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CitiesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CitiesAggregateFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCitiesAggregateFields = () =>
  new CitiesAggregateFieldsQueryBuilder();

export class CitiesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CitiesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CitiesAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCitiesAvgFields = () => new CitiesAvgFieldsQueryBuilder();

export class CitiesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CitiesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CitiesMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCitiesMaxFields = () => new CitiesMaxFieldsQueryBuilder();

export class CitiesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CitiesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CitiesMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCitiesMinFields = () => new CitiesMinFieldsQueryBuilder();

export class CitiesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CitiesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CitiesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCitiesMutationResponse = () =>
  new CitiesMutationResponseQueryBuilder();

export class CitiesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CitiesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CitiesStddevFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCitiesStddevFields = () =>
  new CitiesStddevFieldsQueryBuilder();

export class CitiesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CitiesStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CitiesStddevPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCitiesStddevPopFields = () =>
  new CitiesStddevPopFieldsQueryBuilder();

export class CitiesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CitiesStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CitiesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCitiesStddevSampFields = () =>
  new CitiesStddevSampFieldsQueryBuilder();

export class CitiesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CitiesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CitiesSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCitiesSumFields = () => new CitiesSumFieldsQueryBuilder();

export class CitiesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CitiesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CitiesVarPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCitiesVarPopFields = () =>
  new CitiesVarPopFieldsQueryBuilder();

export class CitiesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CitiesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CitiesVarSampFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCitiesVarSampFields = () =>
  new CitiesVarSampFieldsQueryBuilder();

export class CitiesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CitiesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CitiesVarianceFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCitiesVarianceFields = () =>
  new CitiesVarianceFieldsQueryBuilder();

export class CommentsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Comments> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Comments, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryComments = () => new CommentsQueryBuilder();

export class CommentsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CommentsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CommentsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCommentsAggregate = () => new CommentsAggregateQueryBuilder();

export class CommentsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CommentsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CommentsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCommentsAggregateFields = () =>
  new CommentsAggregateFieldsQueryBuilder();

export class CommentsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CommentsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CommentsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCommentsMaxFields = () => new CommentsMaxFieldsQueryBuilder();

export class CommentsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CommentsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CommentsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCommentsMinFields = () => new CommentsMinFieldsQueryBuilder();

export class CommentsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CommentsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CommentsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCommentsMutationResponse = () =>
  new CommentsMutationResponseQueryBuilder();

export class CompaniesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Companies> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Companies, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanies = () => new CompaniesQueryBuilder();

export class CompaniesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompaniesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CompaniesAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompaniesAggregate = () =>
  new CompaniesAggregateQueryBuilder();

export class CompaniesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompaniesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompaniesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompaniesAggregateFields = () =>
  new CompaniesAggregateFieldsQueryBuilder();

export class CompaniesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompaniesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CompaniesAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompaniesAvgFields = () =>
  new CompaniesAvgFieldsQueryBuilder();

export class CompaniesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompaniesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CompaniesMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompaniesMaxFields = () =>
  new CompaniesMaxFieldsQueryBuilder();

export class CompaniesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompaniesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CompaniesMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompaniesMinFields = () =>
  new CompaniesMinFieldsQueryBuilder();

export class CompaniesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompaniesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompaniesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompaniesMutationResponse = () =>
  new CompaniesMutationResponseQueryBuilder();

export class CompaniesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompaniesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CompaniesStddevFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompaniesStddevFields = () =>
  new CompaniesStddevFieldsQueryBuilder();

export class CompaniesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompaniesStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompaniesStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompaniesStddevPopFields = () =>
  new CompaniesStddevPopFieldsQueryBuilder();

export class CompaniesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompaniesStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompaniesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompaniesStddevSampFields = () =>
  new CompaniesStddevSampFieldsQueryBuilder();

export class CompaniesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompaniesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CompaniesSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompaniesSumFields = () =>
  new CompaniesSumFieldsQueryBuilder();

export class CompaniesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompaniesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CompaniesVarPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompaniesVarPopFields = () =>
  new CompaniesVarPopFieldsQueryBuilder();

export class CompaniesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompaniesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompaniesVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompaniesVarSampFields = () =>
  new CompaniesVarSampFieldsQueryBuilder();

export class CompaniesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompaniesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompaniesVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompaniesVarianceFields = () =>
  new CompaniesVarianceFieldsQueryBuilder();

export class CompanyContactsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyContacts> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CompanyContacts, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyContacts = () => new CompanyContactsQueryBuilder();

export class CompanyContactsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyContactsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyContactsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyContactsAggregate = () =>
  new CompanyContactsAggregateQueryBuilder();

export class CompanyContactsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyContactsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyContactsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyContactsAggregateFields = () =>
  new CompanyContactsAggregateFieldsQueryBuilder();

export class CompanyContactsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyContactsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyContactsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyContactsAvgFields = () =>
  new CompanyContactsAvgFieldsQueryBuilder();

export class CompanyContactsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyContactsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyContactsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyContactsMaxFields = () =>
  new CompanyContactsMaxFieldsQueryBuilder();

export class CompanyContactsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyContactsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyContactsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyContactsMinFields = () =>
  new CompanyContactsMinFieldsQueryBuilder();

export class CompanyContactsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyContactsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyContactsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyContactsMutationResponse = () =>
  new CompanyContactsMutationResponseQueryBuilder();

export class CompanyContactsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyContactsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyContactsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyContactsStddevFields = () =>
  new CompanyContactsStddevFieldsQueryBuilder();

export class CompanyContactsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyContactsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyContactsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyContactsStddevPopFields = () =>
  new CompanyContactsStddevPopFieldsQueryBuilder();

export class CompanyContactsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyContactsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyContactsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyContactsStddevSampFields = () =>
  new CompanyContactsStddevSampFieldsQueryBuilder();

export class CompanyContactsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyContactsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyContactsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyContactsSumFields = () =>
  new CompanyContactsSumFieldsQueryBuilder();

export class CompanyContactsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyContactsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyContactsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyContactsVarPopFields = () =>
  new CompanyContactsVarPopFieldsQueryBuilder();

export class CompanyContactsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyContactsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyContactsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyContactsVarSampFields = () =>
  new CompanyContactsVarSampFieldsQueryBuilder();

export class CompanyContactsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyContactsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyContactsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyContactsVarianceFields = () =>
  new CompanyContactsVarianceFieldsQueryBuilder();

export class CompanyEmployeesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyEmployees> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CompanyEmployees, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyEmployees = () => new CompanyEmployeesQueryBuilder();

export class CompanyEmployeesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyEmployeesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyEmployeesAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyEmployeesAggregate = () =>
  new CompanyEmployeesAggregateQueryBuilder();

export class CompanyEmployeesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyEmployeesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyEmployeesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyEmployeesAggregateFields = () =>
  new CompanyEmployeesAggregateFieldsQueryBuilder();

export class CompanyEmployeesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyEmployeesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyEmployeesMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyEmployeesMaxFields = () =>
  new CompanyEmployeesMaxFieldsQueryBuilder();

export class CompanyEmployeesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyEmployeesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyEmployeesMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyEmployeesMinFields = () =>
  new CompanyEmployeesMinFieldsQueryBuilder();

export class CompanyEmployeesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyEmployeesMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyEmployeesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyEmployeesMutationResponse = () =>
  new CompanyEmployeesMutationResponseQueryBuilder();

export class CompanyExtrasQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyExtras> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CompanyExtras, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyExtras = () => new CompanyExtrasQueryBuilder();

export class CompanyExtrasAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyExtrasAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyExtrasAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyExtrasAggregate = () =>
  new CompanyExtrasAggregateQueryBuilder();

export class CompanyExtrasAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyExtrasAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyExtrasAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyExtrasAggregateFields = () =>
  new CompanyExtrasAggregateFieldsQueryBuilder();

export class CompanyExtrasAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyExtrasAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyExtrasAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyExtrasAvgFields = () =>
  new CompanyExtrasAvgFieldsQueryBuilder();

export class CompanyExtrasMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyExtrasMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyExtrasMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyExtrasMaxFields = () =>
  new CompanyExtrasMaxFieldsQueryBuilder();

export class CompanyExtrasMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyExtrasMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyExtrasMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyExtrasMinFields = () =>
  new CompanyExtrasMinFieldsQueryBuilder();

export class CompanyExtrasMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyExtrasMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyExtrasMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyExtrasMutationResponse = () =>
  new CompanyExtrasMutationResponseQueryBuilder();

export class CompanyExtrasStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyExtrasStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyExtrasStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyExtrasStddevFields = () =>
  new CompanyExtrasStddevFieldsQueryBuilder();

export class CompanyExtrasStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyExtrasStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyExtrasStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyExtrasStddevPopFields = () =>
  new CompanyExtrasStddevPopFieldsQueryBuilder();

export class CompanyExtrasStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyExtrasStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyExtrasStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyExtrasStddevSampFields = () =>
  new CompanyExtrasStddevSampFieldsQueryBuilder();

export class CompanyExtrasSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyExtrasSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyExtrasSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyExtrasSumFields = () =>
  new CompanyExtrasSumFieldsQueryBuilder();

export class CompanyExtrasVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyExtrasVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyExtrasVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyExtrasVarPopFields = () =>
  new CompanyExtrasVarPopFieldsQueryBuilder();

export class CompanyExtrasVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyExtrasVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyExtrasVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyExtrasVarSampFields = () =>
  new CompanyExtrasVarSampFieldsQueryBuilder();

export class CompanyExtrasVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyExtrasVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyExtrasVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyExtrasVarianceFields = () =>
  new CompanyExtrasVarianceFieldsQueryBuilder();

export class CompanyMetricsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyMetrics> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CompanyMetrics, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyMetrics = () => new CompanyMetricsQueryBuilder();

export class CompanyMetricsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyMetricsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyMetricsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyMetricsAggregate = () =>
  new CompanyMetricsAggregateQueryBuilder();

export class CompanyMetricsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyMetricsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyMetricsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyMetricsAggregateFields = () =>
  new CompanyMetricsAggregateFieldsQueryBuilder();

export class CompanyMetricsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyMetricsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyMetricsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyMetricsAvgFields = () =>
  new CompanyMetricsAvgFieldsQueryBuilder();

export class CompanyMetricsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyMetricsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyMetricsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyMetricsMaxFields = () =>
  new CompanyMetricsMaxFieldsQueryBuilder();

export class CompanyMetricsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyMetricsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyMetricsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyMetricsMinFields = () =>
  new CompanyMetricsMinFieldsQueryBuilder();

export class CompanyMetricsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyMetricsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyMetricsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyMetricsMutationResponse = () =>
  new CompanyMetricsMutationResponseQueryBuilder();

export class CompanyMetricsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyMetricsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyMetricsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyMetricsStddevFields = () =>
  new CompanyMetricsStddevFieldsQueryBuilder();

export class CompanyMetricsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyMetricsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyMetricsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyMetricsStddevPopFields = () =>
  new CompanyMetricsStddevPopFieldsQueryBuilder();

export class CompanyMetricsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyMetricsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyMetricsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyMetricsStddevSampFields = () =>
  new CompanyMetricsStddevSampFieldsQueryBuilder();

export class CompanyMetricsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyMetricsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyMetricsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyMetricsSumFields = () =>
  new CompanyMetricsSumFieldsQueryBuilder();

export class CompanyMetricsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyMetricsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyMetricsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyMetricsVarPopFields = () =>
  new CompanyMetricsVarPopFieldsQueryBuilder();

export class CompanyMetricsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyMetricsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyMetricsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyMetricsVarSampFields = () =>
  new CompanyMetricsVarSampFieldsQueryBuilder();

export class CompanyMetricsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CompanyMetricsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CompanyMetricsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCompanyMetricsVarianceFields = () =>
  new CompanyMetricsVarianceFieldsQueryBuilder();

export class ContactsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Contacts> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Contacts, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContacts = () => new ContactsQueryBuilder();

export class ContactsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContactsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContactsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContactsAggregate = () => new ContactsAggregateQueryBuilder();

export class ContactsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContactsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContactsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContactsAggregateFields = () =>
  new ContactsAggregateFieldsQueryBuilder();

export class ContactsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContactsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContactsAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContactsAvgFields = () => new ContactsAvgFieldsQueryBuilder();

export class ContactsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContactsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContactsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContactsMaxFields = () => new ContactsMaxFieldsQueryBuilder();

export class ContactsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContactsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContactsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContactsMinFields = () => new ContactsMinFieldsQueryBuilder();

export class ContactsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContactsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContactsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContactsMutationResponse = () =>
  new ContactsMutationResponseQueryBuilder();

export class ContactsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContactsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContactsStddevFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContactsStddevFields = () =>
  new ContactsStddevFieldsQueryBuilder();

export class ContactsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContactsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContactsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContactsStddevPopFields = () =>
  new ContactsStddevPopFieldsQueryBuilder();

export class ContactsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContactsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContactsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContactsStddevSampFields = () =>
  new ContactsStddevSampFieldsQueryBuilder();

export class ContactsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContactsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContactsSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContactsSumFields = () => new ContactsSumFieldsQueryBuilder();

export class ContactsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContactsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContactsVarPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContactsVarPopFields = () =>
  new ContactsVarPopFieldsQueryBuilder();

export class ContactsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContactsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContactsVarSampFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContactsVarSampFields = () =>
  new ContactsVarSampFieldsQueryBuilder();

export class ContactsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContactsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContactsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContactsVarianceFields = () =>
  new ContactsVarianceFieldsQueryBuilder();

export class ContentCategoriesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentCategories> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentCategories, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentCategories = () => new ContentCategoriesQueryBuilder();

export class ContentCategoriesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentCategoriesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentCategoriesAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentCategoriesAggregate = () =>
  new ContentCategoriesAggregateQueryBuilder();

export class ContentCategoriesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentCategoriesAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentCategoriesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentCategoriesAggregateFields = () =>
  new ContentCategoriesAggregateFieldsQueryBuilder();

export class ContentCategoriesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentCategoriesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentCategoriesAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentCategoriesAvgFields = () =>
  new ContentCategoriesAvgFieldsQueryBuilder();

export class ContentCategoriesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentCategoriesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentCategoriesMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentCategoriesMaxFields = () =>
  new ContentCategoriesMaxFieldsQueryBuilder();

export class ContentCategoriesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentCategoriesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentCategoriesMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentCategoriesMinFields = () =>
  new ContentCategoriesMinFieldsQueryBuilder();

export class ContentCategoriesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentCategoriesMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentCategoriesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentCategoriesMutationResponse = () =>
  new ContentCategoriesMutationResponseQueryBuilder();

export class ContentCategoriesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentCategoriesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentCategoriesStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentCategoriesStddevFields = () =>
  new ContentCategoriesStddevFieldsQueryBuilder();

export class ContentCategoriesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentCategoriesStddevPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentCategoriesStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentCategoriesStddevPopFields = () =>
  new ContentCategoriesStddevPopFieldsQueryBuilder();

export class ContentCategoriesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentCategoriesStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentCategoriesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentCategoriesStddevSampFields = () =>
  new ContentCategoriesStddevSampFieldsQueryBuilder();

export class ContentCategoriesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentCategoriesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentCategoriesSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentCategoriesSumFields = () =>
  new ContentCategoriesSumFieldsQueryBuilder();

export class ContentCategoriesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentCategoriesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentCategoriesVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentCategoriesVarPopFields = () =>
  new ContentCategoriesVarPopFieldsQueryBuilder();

export class ContentCategoriesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentCategoriesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentCategoriesVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentCategoriesVarSampFields = () =>
  new ContentCategoriesVarSampFieldsQueryBuilder();

export class ContentCategoriesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentCategoriesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentCategoriesVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentCategoriesVarianceFields = () =>
  new ContentCategoriesVarianceFieldsQueryBuilder();

export class ContentScoresQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentScores> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentScores, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentScores = () => new ContentScoresQueryBuilder();

export class ContentScoresAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentScoresAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentScoresAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentScoresAggregate = () =>
  new ContentScoresAggregateQueryBuilder();

export class ContentScoresAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentScoresAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentScoresAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentScoresAggregateFields = () =>
  new ContentScoresAggregateFieldsQueryBuilder();

export class ContentScoresAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentScoresAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentScoresAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentScoresAvgFields = () =>
  new ContentScoresAvgFieldsQueryBuilder();

export class ContentScoresMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentScoresMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentScoresMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentScoresMaxFields = () =>
  new ContentScoresMaxFieldsQueryBuilder();

export class ContentScoresMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentScoresMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentScoresMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentScoresMinFields = () =>
  new ContentScoresMinFieldsQueryBuilder();

export class ContentScoresStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentScoresStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentScoresStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentScoresStddevFields = () =>
  new ContentScoresStddevFieldsQueryBuilder();

export class ContentScoresStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentScoresStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentScoresStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentScoresStddevPopFields = () =>
  new ContentScoresStddevPopFieldsQueryBuilder();

export class ContentScoresStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentScoresStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentScoresStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentScoresStddevSampFields = () =>
  new ContentScoresStddevSampFieldsQueryBuilder();

export class ContentScoresSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentScoresSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentScoresSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentScoresSumFields = () =>
  new ContentScoresSumFieldsQueryBuilder();

export class ContentScoresVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentScoresVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentScoresVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentScoresVarPopFields = () =>
  new ContentScoresVarPopFieldsQueryBuilder();

export class ContentScoresVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentScoresVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentScoresVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentScoresVarSampFields = () =>
  new ContentScoresVarSampFieldsQueryBuilder();

export class ContentScoresVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentScoresVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentScoresVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentScoresVarianceFields = () =>
  new ContentScoresVarianceFieldsQueryBuilder();

export class ContentSourceVisitsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourceVisits> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentSourceVisits, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourceVisits = () =>
  new ContentSourceVisitsQueryBuilder();

export class ContentSourceVisitsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourceVisitsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourceVisitsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourceVisitsAggregate = () =>
  new ContentSourceVisitsAggregateQueryBuilder();

export class ContentSourceVisitsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourceVisitsAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourceVisitsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourceVisitsAggregateFields = () =>
  new ContentSourceVisitsAggregateFieldsQueryBuilder();

export class ContentSourceVisitsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourceVisitsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourceVisitsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourceVisitsMaxFields = () =>
  new ContentSourceVisitsMaxFieldsQueryBuilder();

export class ContentSourceVisitsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourceVisitsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourceVisitsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourceVisitsMinFields = () =>
  new ContentSourceVisitsMinFieldsQueryBuilder();

export class ContentSourceVisitsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourceVisitsMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourceVisitsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourceVisitsMutationResponse = () =>
  new ContentSourceVisitsMutationResponseQueryBuilder();

export class ContentSourcesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSources> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentSources, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSources = () => new ContentSourcesQueryBuilder();

export class ContentSourcesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourcesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourcesAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourcesAggregate = () =>
  new ContentSourcesAggregateQueryBuilder();

export class ContentSourcesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourcesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourcesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourcesAggregateFields = () =>
  new ContentSourcesAggregateFieldsQueryBuilder();

export class ContentSourcesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourcesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourcesAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourcesAvgFields = () =>
  new ContentSourcesAvgFieldsQueryBuilder();

export class ContentSourcesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourcesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourcesMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourcesMaxFields = () =>
  new ContentSourcesMaxFieldsQueryBuilder();

export class ContentSourcesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourcesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourcesMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourcesMinFields = () =>
  new ContentSourcesMinFieldsQueryBuilder();

export class ContentSourcesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourcesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourcesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourcesMutationResponse = () =>
  new ContentSourcesMutationResponseQueryBuilder();

export class ContentSourcesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourcesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourcesStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourcesStddevFields = () =>
  new ContentSourcesStddevFieldsQueryBuilder();

export class ContentSourcesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourcesStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourcesStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourcesStddevPopFields = () =>
  new ContentSourcesStddevPopFieldsQueryBuilder();

export class ContentSourcesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourcesStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourcesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourcesStddevSampFields = () =>
  new ContentSourcesStddevSampFieldsQueryBuilder();

export class ContentSourcesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourcesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourcesSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourcesSumFields = () =>
  new ContentSourcesSumFieldsQueryBuilder();

export class ContentSourcesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourcesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourcesVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourcesVarPopFields = () =>
  new ContentSourcesVarPopFieldsQueryBuilder();

export class ContentSourcesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourcesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourcesVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourcesVarSampFields = () =>
  new ContentSourcesVarSampFieldsQueryBuilder();

export class ContentSourcesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentSourcesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentSourcesVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentSourcesVarianceFields = () =>
  new ContentSourcesVarianceFieldsQueryBuilder();

export class ContentStatusesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentStatuses> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentStatuses, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentStatuses = () => new ContentStatusesQueryBuilder();

export class ContentStatusesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentStatusesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentStatusesAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentStatusesAggregate = () =>
  new ContentStatusesAggregateQueryBuilder();

export class ContentStatusesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentStatusesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentStatusesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentStatusesAggregateFields = () =>
  new ContentStatusesAggregateFieldsQueryBuilder();

export class ContentStatusesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentStatusesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentStatusesMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentStatusesMaxFields = () =>
  new ContentStatusesMaxFieldsQueryBuilder();

export class ContentStatusesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentStatusesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentStatusesMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentStatusesMinFields = () =>
  new ContentStatusesMinFieldsQueryBuilder();

export class ContentStatusesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentStatusesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentStatusesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentStatusesMutationResponse = () =>
  new ContentStatusesMutationResponseQueryBuilder();

export class ContentTagsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentTags> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentTags, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentTags = () => new ContentTagsQueryBuilder();

export class ContentTagsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentTagsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentTagsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentTagsAggregate = () =>
  new ContentTagsAggregateQueryBuilder();

export class ContentTagsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentTagsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentTagsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentTagsAggregateFields = () =>
  new ContentTagsAggregateFieldsQueryBuilder();

export class ContentTagsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentTagsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentTagsAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentTagsAvgFields = () =>
  new ContentTagsAvgFieldsQueryBuilder();

export class ContentTagsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentTagsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentTagsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentTagsMaxFields = () =>
  new ContentTagsMaxFieldsQueryBuilder();

export class ContentTagsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentTagsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentTagsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentTagsMinFields = () =>
  new ContentTagsMinFieldsQueryBuilder();

export class ContentTagsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentTagsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentTagsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentTagsMutationResponse = () =>
  new ContentTagsMutationResponseQueryBuilder();

export class ContentTagsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentTagsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentTagsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentTagsStddevFields = () =>
  new ContentTagsStddevFieldsQueryBuilder();

export class ContentTagsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentTagsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentTagsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentTagsStddevPopFields = () =>
  new ContentTagsStddevPopFieldsQueryBuilder();

export class ContentTagsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentTagsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentTagsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentTagsStddevSampFields = () =>
  new ContentTagsStddevSampFieldsQueryBuilder();

export class ContentTagsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentTagsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentTagsSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentTagsSumFields = () =>
  new ContentTagsSumFieldsQueryBuilder();

export class ContentTagsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentTagsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentTagsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentTagsVarPopFields = () =>
  new ContentTagsVarPopFieldsQueryBuilder();

export class ContentTagsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentTagsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentTagsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentTagsVarSampFields = () =>
  new ContentTagsVarSampFieldsQueryBuilder();

export class ContentTagsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentTagsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentTagsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentTagsVarianceFields = () =>
  new ContentTagsVarianceFieldsQueryBuilder();

export class ContentsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Contents> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Contents, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContents = () => new ContentsQueryBuilder();

export class ContentsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentsAggregate = () => new ContentsAggregateQueryBuilder();

export class ContentsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentsAggregateFields = () =>
  new ContentsAggregateFieldsQueryBuilder();

export class ContentsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentsAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentsAvgFields = () => new ContentsAvgFieldsQueryBuilder();

export class ContentsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentsMaxFields = () => new ContentsMaxFieldsQueryBuilder();

export class ContentsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentsMinFields = () => new ContentsMinFieldsQueryBuilder();

export class ContentsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentsMutationResponse = () =>
  new ContentsMutationResponseQueryBuilder();

export class ContentsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentsStddevFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentsStddevFields = () =>
  new ContentsStddevFieldsQueryBuilder();

export class ContentsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentsStddevPopFields = () =>
  new ContentsStddevPopFieldsQueryBuilder();

export class ContentsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentsStddevSampFields = () =>
  new ContentsStddevSampFieldsQueryBuilder();

export class ContentsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentsSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentsSumFields = () => new ContentsSumFieldsQueryBuilder();

export class ContentsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentsVarPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentsVarPopFields = () =>
  new ContentsVarPopFieldsQueryBuilder();

export class ContentsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ContentsVarSampFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentsVarSampFields = () =>
  new ContentsVarSampFieldsQueryBuilder();

export class ContentsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ContentsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ContentsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryContentsVarianceFields = () =>
  new ContentsVarianceFieldsQueryBuilder();

export class CountriesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Countries> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Countries, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCountries = () => new CountriesQueryBuilder();

export class CountriesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CountriesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CountriesAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCountriesAggregate = () =>
  new CountriesAggregateQueryBuilder();

export class CountriesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CountriesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CountriesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCountriesAggregateFields = () =>
  new CountriesAggregateFieldsQueryBuilder();

export class CountriesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CountriesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CountriesAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCountriesAvgFields = () =>
  new CountriesAvgFieldsQueryBuilder();

export class CountriesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CountriesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CountriesMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCountriesMaxFields = () =>
  new CountriesMaxFieldsQueryBuilder();

export class CountriesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CountriesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CountriesMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCountriesMinFields = () =>
  new CountriesMinFieldsQueryBuilder();

export class CountriesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CountriesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CountriesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCountriesMutationResponse = () =>
  new CountriesMutationResponseQueryBuilder();

export class CountriesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CountriesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CountriesStddevFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCountriesStddevFields = () =>
  new CountriesStddevFieldsQueryBuilder();

export class CountriesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CountriesStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CountriesStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCountriesStddevPopFields = () =>
  new CountriesStddevPopFieldsQueryBuilder();

export class CountriesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CountriesStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CountriesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCountriesStddevSampFields = () =>
  new CountriesStddevSampFieldsQueryBuilder();

export class CountriesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CountriesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CountriesSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCountriesSumFields = () =>
  new CountriesSumFieldsQueryBuilder();

export class CountriesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CountriesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CountriesVarPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCountriesVarPopFields = () =>
  new CountriesVarPopFieldsQueryBuilder();

export class CountriesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CountriesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CountriesVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCountriesVarSampFields = () =>
  new CountriesVarSampFieldsQueryBuilder();

export class CountriesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CountriesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CountriesVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCountriesVarianceFields = () =>
  new CountriesVarianceFieldsQueryBuilder();

export class CustomerPaymentsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerPayments> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CustomerPayments, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerPayments = () => new CustomerPaymentsQueryBuilder();

export class CustomerPaymentsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerPaymentsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerPaymentsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerPaymentsAggregate = () =>
  new CustomerPaymentsAggregateQueryBuilder();

export class CustomerPaymentsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerPaymentsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerPaymentsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerPaymentsAggregateFields = () =>
  new CustomerPaymentsAggregateFieldsQueryBuilder();

export class CustomerPaymentsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerPaymentsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerPaymentsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerPaymentsAvgFields = () =>
  new CustomerPaymentsAvgFieldsQueryBuilder();

export class CustomerPaymentsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerPaymentsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerPaymentsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerPaymentsMaxFields = () =>
  new CustomerPaymentsMaxFieldsQueryBuilder();

export class CustomerPaymentsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerPaymentsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerPaymentsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerPaymentsMinFields = () =>
  new CustomerPaymentsMinFieldsQueryBuilder();

export class CustomerPaymentsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerPaymentsMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerPaymentsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerPaymentsMutationResponse = () =>
  new CustomerPaymentsMutationResponseQueryBuilder();

export class CustomerPaymentsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerPaymentsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerPaymentsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerPaymentsStddevFields = () =>
  new CustomerPaymentsStddevFieldsQueryBuilder();

export class CustomerPaymentsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerPaymentsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerPaymentsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerPaymentsStddevPopFields = () =>
  new CustomerPaymentsStddevPopFieldsQueryBuilder();

export class CustomerPaymentsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerPaymentsStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerPaymentsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerPaymentsStddevSampFields = () =>
  new CustomerPaymentsStddevSampFieldsQueryBuilder();

export class CustomerPaymentsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerPaymentsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerPaymentsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerPaymentsSumFields = () =>
  new CustomerPaymentsSumFieldsQueryBuilder();

export class CustomerPaymentsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerPaymentsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerPaymentsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerPaymentsVarPopFields = () =>
  new CustomerPaymentsVarPopFieldsQueryBuilder();

export class CustomerPaymentsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerPaymentsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerPaymentsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerPaymentsVarSampFields = () =>
  new CustomerPaymentsVarSampFieldsQueryBuilder();

export class CustomerPaymentsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerPaymentsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerPaymentsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerPaymentsVarianceFields = () =>
  new CustomerPaymentsVarianceFieldsQueryBuilder();

export class CustomerProcessedWebhooksQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerProcessedWebhooks> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerProcessedWebhooks,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerProcessedWebhooks = () =>
  new CustomerProcessedWebhooksQueryBuilder();

export class CustomerProcessedWebhooksAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerProcessedWebhooksAggregate> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerProcessedWebhooksAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerProcessedWebhooksAggregate = () =>
  new CustomerProcessedWebhooksAggregateQueryBuilder();

export class CustomerProcessedWebhooksAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerProcessedWebhooksAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerProcessedWebhooksAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerProcessedWebhooksAggregateFields = () =>
  new CustomerProcessedWebhooksAggregateFieldsQueryBuilder();

export class CustomerProcessedWebhooksAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerProcessedWebhooksAvgFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerProcessedWebhooksAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerProcessedWebhooksAvgFields = () =>
  new CustomerProcessedWebhooksAvgFieldsQueryBuilder();

export class CustomerProcessedWebhooksMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerProcessedWebhooksMaxFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerProcessedWebhooksMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerProcessedWebhooksMaxFields = () =>
  new CustomerProcessedWebhooksMaxFieldsQueryBuilder();

export class CustomerProcessedWebhooksMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerProcessedWebhooksMinFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerProcessedWebhooksMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerProcessedWebhooksMinFields = () =>
  new CustomerProcessedWebhooksMinFieldsQueryBuilder();

export class CustomerProcessedWebhooksMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerProcessedWebhooksMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerProcessedWebhooksMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerProcessedWebhooksMutationResponse = () =>
  new CustomerProcessedWebhooksMutationResponseQueryBuilder();

export class CustomerProcessedWebhooksStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerProcessedWebhooksStddevFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerProcessedWebhooksStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerProcessedWebhooksStddevFields = () =>
  new CustomerProcessedWebhooksStddevFieldsQueryBuilder();

export class CustomerProcessedWebhooksStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerProcessedWebhooksStddevPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerProcessedWebhooksStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerProcessedWebhooksStddevPopFields = () =>
  new CustomerProcessedWebhooksStddevPopFieldsQueryBuilder();

export class CustomerProcessedWebhooksStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerProcessedWebhooksStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerProcessedWebhooksStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerProcessedWebhooksStddevSampFields = () =>
  new CustomerProcessedWebhooksStddevSampFieldsQueryBuilder();

export class CustomerProcessedWebhooksSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerProcessedWebhooksSumFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerProcessedWebhooksSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerProcessedWebhooksSumFields = () =>
  new CustomerProcessedWebhooksSumFieldsQueryBuilder();

export class CustomerProcessedWebhooksVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerProcessedWebhooksVarPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerProcessedWebhooksVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerProcessedWebhooksVarPopFields = () =>
  new CustomerProcessedWebhooksVarPopFieldsQueryBuilder();

export class CustomerProcessedWebhooksVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerProcessedWebhooksVarSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerProcessedWebhooksVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerProcessedWebhooksVarSampFields = () =>
  new CustomerProcessedWebhooksVarSampFieldsQueryBuilder();

export class CustomerProcessedWebhooksVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerProcessedWebhooksVarianceFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerProcessedWebhooksVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerProcessedWebhooksVarianceFields = () =>
  new CustomerProcessedWebhooksVarianceFieldsQueryBuilder();

export class CustomerRefundsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerRefunds> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CustomerRefunds, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerRefunds = () => new CustomerRefundsQueryBuilder();

export class CustomerRefundsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerRefundsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerRefundsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerRefundsAggregate = () =>
  new CustomerRefundsAggregateQueryBuilder();

export class CustomerRefundsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerRefundsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerRefundsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerRefundsAggregateFields = () =>
  new CustomerRefundsAggregateFieldsQueryBuilder();

export class CustomerRefundsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerRefundsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerRefundsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerRefundsAvgFields = () =>
  new CustomerRefundsAvgFieldsQueryBuilder();

export class CustomerRefundsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerRefundsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerRefundsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerRefundsMaxFields = () =>
  new CustomerRefundsMaxFieldsQueryBuilder();

export class CustomerRefundsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerRefundsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerRefundsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerRefundsMinFields = () =>
  new CustomerRefundsMinFieldsQueryBuilder();

export class CustomerRefundsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerRefundsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerRefundsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerRefundsMutationResponse = () =>
  new CustomerRefundsMutationResponseQueryBuilder();

export class CustomerRefundsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerRefundsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerRefundsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerRefundsStddevFields = () =>
  new CustomerRefundsStddevFieldsQueryBuilder();

export class CustomerRefundsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerRefundsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerRefundsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerRefundsStddevPopFields = () =>
  new CustomerRefundsStddevPopFieldsQueryBuilder();

export class CustomerRefundsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerRefundsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerRefundsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerRefundsStddevSampFields = () =>
  new CustomerRefundsStddevSampFieldsQueryBuilder();

export class CustomerRefundsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerRefundsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerRefundsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerRefundsSumFields = () =>
  new CustomerRefundsSumFieldsQueryBuilder();

export class CustomerRefundsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerRefundsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerRefundsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerRefundsVarPopFields = () =>
  new CustomerRefundsVarPopFieldsQueryBuilder();

export class CustomerRefundsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerRefundsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerRefundsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerRefundsVarSampFields = () =>
  new CustomerRefundsVarSampFieldsQueryBuilder();

export class CustomerRefundsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerRefundsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerRefundsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerRefundsVarianceFields = () =>
  new CustomerRefundsVarianceFieldsQueryBuilder();

export class CustomerSubscriptionPlansQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionPlans> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionPlans,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionPlans = () =>
  new CustomerSubscriptionPlansQueryBuilder();

export class CustomerSubscriptionPlansAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionPlansAggregate> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionPlansAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionPlansAggregate = () =>
  new CustomerSubscriptionPlansAggregateQueryBuilder();

export class CustomerSubscriptionPlansAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionPlansAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionPlansAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionPlansAggregateFields = () =>
  new CustomerSubscriptionPlansAggregateFieldsQueryBuilder();

export class CustomerSubscriptionPlansAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionPlansAvgFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionPlansAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionPlansAvgFields = () =>
  new CustomerSubscriptionPlansAvgFieldsQueryBuilder();

export class CustomerSubscriptionPlansMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionPlansMaxFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionPlansMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionPlansMaxFields = () =>
  new CustomerSubscriptionPlansMaxFieldsQueryBuilder();

export class CustomerSubscriptionPlansMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionPlansMinFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionPlansMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionPlansMinFields = () =>
  new CustomerSubscriptionPlansMinFieldsQueryBuilder();

export class CustomerSubscriptionPlansMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionPlansMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionPlansMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionPlansMutationResponse = () =>
  new CustomerSubscriptionPlansMutationResponseQueryBuilder();

export class CustomerSubscriptionPlansStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionPlansStddevFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionPlansStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionPlansStddevFields = () =>
  new CustomerSubscriptionPlansStddevFieldsQueryBuilder();

export class CustomerSubscriptionPlansStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionPlansStddevPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionPlansStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionPlansStddevPopFields = () =>
  new CustomerSubscriptionPlansStddevPopFieldsQueryBuilder();

export class CustomerSubscriptionPlansStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionPlansStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionPlansStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionPlansStddevSampFields = () =>
  new CustomerSubscriptionPlansStddevSampFieldsQueryBuilder();

export class CustomerSubscriptionPlansSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionPlansSumFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionPlansSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionPlansSumFields = () =>
  new CustomerSubscriptionPlansSumFieldsQueryBuilder();

export class CustomerSubscriptionPlansVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionPlansVarPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionPlansVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionPlansVarPopFields = () =>
  new CustomerSubscriptionPlansVarPopFieldsQueryBuilder();

export class CustomerSubscriptionPlansVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionPlansVarSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionPlansVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionPlansVarSampFields = () =>
  new CustomerSubscriptionPlansVarSampFieldsQueryBuilder();

export class CustomerSubscriptionPlansVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionPlansVarianceFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionPlansVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionPlansVarianceFields = () =>
  new CustomerSubscriptionPlansVarianceFieldsQueryBuilder();

export class CustomerSubscriptionsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptions> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.CustomerSubscriptions, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptions = () =>
  new CustomerSubscriptionsQueryBuilder();

export class CustomerSubscriptionsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionsAggregate = () =>
  new CustomerSubscriptionsAggregateQueryBuilder();

export class CustomerSubscriptionsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionsAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionsAggregateFields = () =>
  new CustomerSubscriptionsAggregateFieldsQueryBuilder();

export class CustomerSubscriptionsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionsAvgFields = () =>
  new CustomerSubscriptionsAvgFieldsQueryBuilder();

export class CustomerSubscriptionsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionsMaxFields = () =>
  new CustomerSubscriptionsMaxFieldsQueryBuilder();

export class CustomerSubscriptionsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionsMinFields = () =>
  new CustomerSubscriptionsMinFieldsQueryBuilder();

export class CustomerSubscriptionsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionsMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionsMutationResponse = () =>
  new CustomerSubscriptionsMutationResponseQueryBuilder();

export class CustomerSubscriptionsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionsStddevFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionsStddevFields = () =>
  new CustomerSubscriptionsStddevFieldsQueryBuilder();

export class CustomerSubscriptionsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionsStddevPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionsStddevPopFields = () =>
  new CustomerSubscriptionsStddevPopFieldsQueryBuilder();

export class CustomerSubscriptionsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionsStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionsStddevSampFields = () =>
  new CustomerSubscriptionsStddevSampFieldsQueryBuilder();

export class CustomerSubscriptionsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionsSumFields = () =>
  new CustomerSubscriptionsSumFieldsQueryBuilder();

export class CustomerSubscriptionsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionsVarPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionsVarPopFields = () =>
  new CustomerSubscriptionsVarPopFieldsQueryBuilder();

export class CustomerSubscriptionsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionsVarSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionsVarSampFields = () =>
  new CustomerSubscriptionsVarSampFieldsQueryBuilder();

export class CustomerSubscriptionsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.CustomerSubscriptionsVarianceFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.CustomerSubscriptionsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryCustomerSubscriptionsVarianceFields = () =>
  new CustomerSubscriptionsVarianceFieldsQueryBuilder();

export class EmbeddingReviewsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.EmbeddingReviews> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.EmbeddingReviews, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryEmbeddingReviews = () => new EmbeddingReviewsQueryBuilder();

export class EmbeddingReviewsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.EmbeddingReviewsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.EmbeddingReviewsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryEmbeddingReviewsAggregate = () =>
  new EmbeddingReviewsAggregateQueryBuilder();

export class EmbeddingReviewsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.EmbeddingReviewsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.EmbeddingReviewsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryEmbeddingReviewsAggregateFields = () =>
  new EmbeddingReviewsAggregateFieldsQueryBuilder();

export class EmbeddingReviewsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.EmbeddingReviewsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.EmbeddingReviewsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryEmbeddingReviewsAvgFields = () =>
  new EmbeddingReviewsAvgFieldsQueryBuilder();

export class EmbeddingReviewsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.EmbeddingReviewsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.EmbeddingReviewsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryEmbeddingReviewsMaxFields = () =>
  new EmbeddingReviewsMaxFieldsQueryBuilder();

export class EmbeddingReviewsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.EmbeddingReviewsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.EmbeddingReviewsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryEmbeddingReviewsMinFields = () =>
  new EmbeddingReviewsMinFieldsQueryBuilder();

export class EmbeddingReviewsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.EmbeddingReviewsMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.EmbeddingReviewsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryEmbeddingReviewsMutationResponse = () =>
  new EmbeddingReviewsMutationResponseQueryBuilder();

export class EmbeddingReviewsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.EmbeddingReviewsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.EmbeddingReviewsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryEmbeddingReviewsStddevFields = () =>
  new EmbeddingReviewsStddevFieldsQueryBuilder();

export class EmbeddingReviewsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.EmbeddingReviewsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.EmbeddingReviewsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryEmbeddingReviewsStddevPopFields = () =>
  new EmbeddingReviewsStddevPopFieldsQueryBuilder();

export class EmbeddingReviewsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.EmbeddingReviewsStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.EmbeddingReviewsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryEmbeddingReviewsStddevSampFields = () =>
  new EmbeddingReviewsStddevSampFieldsQueryBuilder();

export class EmbeddingReviewsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.EmbeddingReviewsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.EmbeddingReviewsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryEmbeddingReviewsSumFields = () =>
  new EmbeddingReviewsSumFieldsQueryBuilder();

export class EmbeddingReviewsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.EmbeddingReviewsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.EmbeddingReviewsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryEmbeddingReviewsVarPopFields = () =>
  new EmbeddingReviewsVarPopFieldsQueryBuilder();

export class EmbeddingReviewsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.EmbeddingReviewsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.EmbeddingReviewsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryEmbeddingReviewsVarSampFields = () =>
  new EmbeddingReviewsVarSampFieldsQueryBuilder();

export class EmbeddingReviewsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.EmbeddingReviewsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.EmbeddingReviewsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryEmbeddingReviewsVarianceFields = () =>
  new EmbeddingReviewsVarianceFieldsQueryBuilder();

export class ErrorCorrelationsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorCorrelations> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorCorrelations, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorCorrelations = () => new ErrorCorrelationsQueryBuilder();

export class ErrorCorrelationsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorCorrelationsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorCorrelationsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorCorrelationsAggregate = () =>
  new ErrorCorrelationsAggregateQueryBuilder();

export class ErrorCorrelationsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorCorrelationsAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorCorrelationsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorCorrelationsAggregateFields = () =>
  new ErrorCorrelationsAggregateFieldsQueryBuilder();

export class ErrorCorrelationsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorCorrelationsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorCorrelationsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorCorrelationsAvgFields = () =>
  new ErrorCorrelationsAvgFieldsQueryBuilder();

export class ErrorCorrelationsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorCorrelationsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorCorrelationsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorCorrelationsMaxFields = () =>
  new ErrorCorrelationsMaxFieldsQueryBuilder();

export class ErrorCorrelationsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorCorrelationsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorCorrelationsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorCorrelationsMinFields = () =>
  new ErrorCorrelationsMinFieldsQueryBuilder();

export class ErrorCorrelationsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorCorrelationsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorCorrelationsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorCorrelationsStddevFields = () =>
  new ErrorCorrelationsStddevFieldsQueryBuilder();

export class ErrorCorrelationsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorCorrelationsStddevPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorCorrelationsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorCorrelationsStddevPopFields = () =>
  new ErrorCorrelationsStddevPopFieldsQueryBuilder();

export class ErrorCorrelationsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorCorrelationsStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorCorrelationsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorCorrelationsStddevSampFields = () =>
  new ErrorCorrelationsStddevSampFieldsQueryBuilder();

export class ErrorCorrelationsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorCorrelationsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorCorrelationsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorCorrelationsSumFields = () =>
  new ErrorCorrelationsSumFieldsQueryBuilder();

export class ErrorCorrelationsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorCorrelationsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorCorrelationsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorCorrelationsVarPopFields = () =>
  new ErrorCorrelationsVarPopFieldsQueryBuilder();

export class ErrorCorrelationsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorCorrelationsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorCorrelationsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorCorrelationsVarSampFields = () =>
  new ErrorCorrelationsVarSampFieldsQueryBuilder();

export class ErrorCorrelationsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorCorrelationsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorCorrelationsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorCorrelationsVarianceFields = () =>
  new ErrorCorrelationsVarianceFieldsQueryBuilder();

export class ErrorFrequencyQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorFrequency> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorFrequency, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorFrequency = () => new ErrorFrequencyQueryBuilder();

export class ErrorFrequencyAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorFrequencyAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorFrequencyAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorFrequencyAggregate = () =>
  new ErrorFrequencyAggregateQueryBuilder();

export class ErrorFrequencyAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorFrequencyAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorFrequencyAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorFrequencyAggregateFields = () =>
  new ErrorFrequencyAggregateFieldsQueryBuilder();

export class ErrorFrequencyAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorFrequencyAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorFrequencyAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorFrequencyAvgFields = () =>
  new ErrorFrequencyAvgFieldsQueryBuilder();

export class ErrorFrequencyMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorFrequencyMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorFrequencyMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorFrequencyMaxFields = () =>
  new ErrorFrequencyMaxFieldsQueryBuilder();

export class ErrorFrequencyMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorFrequencyMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorFrequencyMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorFrequencyMinFields = () =>
  new ErrorFrequencyMinFieldsQueryBuilder();

export class ErrorFrequencyStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorFrequencyStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorFrequencyStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorFrequencyStddevFields = () =>
  new ErrorFrequencyStddevFieldsQueryBuilder();

export class ErrorFrequencyStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorFrequencyStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorFrequencyStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorFrequencyStddevPopFields = () =>
  new ErrorFrequencyStddevPopFieldsQueryBuilder();

export class ErrorFrequencyStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorFrequencyStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorFrequencyStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorFrequencyStddevSampFields = () =>
  new ErrorFrequencyStddevSampFieldsQueryBuilder();

export class ErrorFrequencySumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorFrequencySumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorFrequencySumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorFrequencySumFields = () =>
  new ErrorFrequencySumFieldsQueryBuilder();

export class ErrorFrequencyVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorFrequencyVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorFrequencyVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorFrequencyVarPopFields = () =>
  new ErrorFrequencyVarPopFieldsQueryBuilder();

export class ErrorFrequencyVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorFrequencyVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorFrequencyVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorFrequencyVarSampFields = () =>
  new ErrorFrequencyVarSampFieldsQueryBuilder();

export class ErrorFrequencyVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorFrequencyVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorFrequencyVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorFrequencyVarianceFields = () =>
  new ErrorFrequencyVarianceFieldsQueryBuilder();

export class ErrorLogsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorLogs> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorLogs, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorLogs = () => new ErrorLogsQueryBuilder();

export class ErrorLogsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorLogsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorLogsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorLogsAggregate = () =>
  new ErrorLogsAggregateQueryBuilder();

export class ErrorLogsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorLogsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorLogsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorLogsAggregateFields = () =>
  new ErrorLogsAggregateFieldsQueryBuilder();

export class ErrorLogsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorLogsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorLogsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorLogsMaxFields = () =>
  new ErrorLogsMaxFieldsQueryBuilder();

export class ErrorLogsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorLogsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorLogsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorLogsMinFields = () =>
  new ErrorLogsMinFieldsQueryBuilder();

export class ErrorLogsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorLogsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorLogsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorLogsMutationResponse = () =>
  new ErrorLogsMutationResponseQueryBuilder();

export class ErrorMetricsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorMetrics> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorMetrics, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorMetrics = () => new ErrorMetricsQueryBuilder();

export class ErrorMetricsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorMetricsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorMetricsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorMetricsAggregate = () =>
  new ErrorMetricsAggregateQueryBuilder();

export class ErrorMetricsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorMetricsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorMetricsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorMetricsAggregateFields = () =>
  new ErrorMetricsAggregateFieldsQueryBuilder();

export class ErrorMetricsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorMetricsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorMetricsAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorMetricsAvgFields = () =>
  new ErrorMetricsAvgFieldsQueryBuilder();

export class ErrorMetricsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorMetricsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorMetricsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorMetricsMaxFields = () =>
  new ErrorMetricsMaxFieldsQueryBuilder();

export class ErrorMetricsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorMetricsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorMetricsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorMetricsMinFields = () =>
  new ErrorMetricsMinFieldsQueryBuilder();

export class ErrorMetricsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorMetricsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorMetricsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorMetricsStddevFields = () =>
  new ErrorMetricsStddevFieldsQueryBuilder();

export class ErrorMetricsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorMetricsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorMetricsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorMetricsStddevPopFields = () =>
  new ErrorMetricsStddevPopFieldsQueryBuilder();

export class ErrorMetricsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorMetricsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorMetricsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorMetricsStddevSampFields = () =>
  new ErrorMetricsStddevSampFieldsQueryBuilder();

export class ErrorMetricsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorMetricsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorMetricsSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorMetricsSumFields = () =>
  new ErrorMetricsSumFieldsQueryBuilder();

export class ErrorMetricsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorMetricsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorMetricsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorMetricsVarPopFields = () =>
  new ErrorMetricsVarPopFieldsQueryBuilder();

export class ErrorMetricsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorMetricsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorMetricsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorMetricsVarSampFields = () =>
  new ErrorMetricsVarSampFieldsQueryBuilder();

export class ErrorMetricsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorMetricsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorMetricsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorMetricsVarianceFields = () =>
  new ErrorMetricsVarianceFieldsQueryBuilder();

export class ErrorPatternsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorPatterns> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorPatterns, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorPatterns = () => new ErrorPatternsQueryBuilder();

export class ErrorPatternsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorPatternsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorPatternsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorPatternsAggregate = () =>
  new ErrorPatternsAggregateQueryBuilder();

export class ErrorPatternsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorPatternsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorPatternsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorPatternsAggregateFields = () =>
  new ErrorPatternsAggregateFieldsQueryBuilder();

export class ErrorPatternsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorPatternsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorPatternsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorPatternsAvgFields = () =>
  new ErrorPatternsAvgFieldsQueryBuilder();

export class ErrorPatternsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorPatternsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorPatternsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorPatternsMaxFields = () =>
  new ErrorPatternsMaxFieldsQueryBuilder();

export class ErrorPatternsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorPatternsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorPatternsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorPatternsMinFields = () =>
  new ErrorPatternsMinFieldsQueryBuilder();

export class ErrorPatternsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorPatternsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorPatternsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorPatternsStddevFields = () =>
  new ErrorPatternsStddevFieldsQueryBuilder();

export class ErrorPatternsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorPatternsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorPatternsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorPatternsStddevPopFields = () =>
  new ErrorPatternsStddevPopFieldsQueryBuilder();

export class ErrorPatternsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorPatternsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorPatternsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorPatternsStddevSampFields = () =>
  new ErrorPatternsStddevSampFieldsQueryBuilder();

export class ErrorPatternsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorPatternsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorPatternsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorPatternsSumFields = () =>
  new ErrorPatternsSumFieldsQueryBuilder();

export class ErrorPatternsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorPatternsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorPatternsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorPatternsVarPopFields = () =>
  new ErrorPatternsVarPopFieldsQueryBuilder();

export class ErrorPatternsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorPatternsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorPatternsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorPatternsVarSampFields = () =>
  new ErrorPatternsVarSampFieldsQueryBuilder();

export class ErrorPatternsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorPatternsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorPatternsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorPatternsVarianceFields = () =>
  new ErrorPatternsVarianceFieldsQueryBuilder();

export class ErrorStatsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorStats> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorStats, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorStats = () => new ErrorStatsQueryBuilder();

export class ErrorStatsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorStatsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorStatsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorStatsAggregate = () =>
  new ErrorStatsAggregateQueryBuilder();

export class ErrorStatsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorStatsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorStatsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorStatsAggregateFields = () =>
  new ErrorStatsAggregateFieldsQueryBuilder();

export class ErrorStatsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorStatsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorStatsAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorStatsAvgFields = () =>
  new ErrorStatsAvgFieldsQueryBuilder();

export class ErrorStatsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorStatsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorStatsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorStatsMaxFields = () =>
  new ErrorStatsMaxFieldsQueryBuilder();

export class ErrorStatsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorStatsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorStatsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorStatsMinFields = () =>
  new ErrorStatsMinFieldsQueryBuilder();

export class ErrorStatsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorStatsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorStatsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorStatsStddevFields = () =>
  new ErrorStatsStddevFieldsQueryBuilder();

export class ErrorStatsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorStatsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorStatsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorStatsStddevPopFields = () =>
  new ErrorStatsStddevPopFieldsQueryBuilder();

export class ErrorStatsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorStatsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorStatsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorStatsStddevSampFields = () =>
  new ErrorStatsStddevSampFieldsQueryBuilder();

export class ErrorStatsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorStatsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ErrorStatsSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorStatsSumFields = () =>
  new ErrorStatsSumFieldsQueryBuilder();

export class ErrorStatsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorStatsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorStatsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorStatsVarPopFields = () =>
  new ErrorStatsVarPopFieldsQueryBuilder();

export class ErrorStatsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorStatsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorStatsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorStatsVarSampFields = () =>
  new ErrorStatsVarSampFieldsQueryBuilder();

export class ErrorStatsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ErrorStatsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ErrorStatsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryErrorStatsVarianceFields = () =>
  new ErrorStatsVarianceFieldsQueryBuilder();

export class FeatureRequestsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureRequests> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeatureRequests, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureRequests = () => new FeatureRequestsQueryBuilder();

export class FeatureRequestsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureRequestsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureRequestsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureRequestsAggregate = () =>
  new FeatureRequestsAggregateQueryBuilder();

export class FeatureRequestsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureRequestsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureRequestsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureRequestsAggregateFields = () =>
  new FeatureRequestsAggregateFieldsQueryBuilder();

export class FeatureRequestsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureRequestsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureRequestsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureRequestsAvgFields = () =>
  new FeatureRequestsAvgFieldsQueryBuilder();

export class FeatureRequestsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureRequestsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureRequestsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureRequestsMaxFields = () =>
  new FeatureRequestsMaxFieldsQueryBuilder();

export class FeatureRequestsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureRequestsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureRequestsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureRequestsMinFields = () =>
  new FeatureRequestsMinFieldsQueryBuilder();

export class FeatureRequestsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureRequestsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureRequestsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureRequestsMutationResponse = () =>
  new FeatureRequestsMutationResponseQueryBuilder();

export class FeatureRequestsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureRequestsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureRequestsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureRequestsStddevFields = () =>
  new FeatureRequestsStddevFieldsQueryBuilder();

export class FeatureRequestsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureRequestsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureRequestsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureRequestsStddevPopFields = () =>
  new FeatureRequestsStddevPopFieldsQueryBuilder();

export class FeatureRequestsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureRequestsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureRequestsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureRequestsStddevSampFields = () =>
  new FeatureRequestsStddevSampFieldsQueryBuilder();

export class FeatureRequestsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureRequestsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureRequestsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureRequestsSumFields = () =>
  new FeatureRequestsSumFieldsQueryBuilder();

export class FeatureRequestsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureRequestsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureRequestsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureRequestsVarPopFields = () =>
  new FeatureRequestsVarPopFieldsQueryBuilder();

export class FeatureRequestsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureRequestsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureRequestsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureRequestsVarSampFields = () =>
  new FeatureRequestsVarSampFieldsQueryBuilder();

export class FeatureRequestsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureRequestsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureRequestsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureRequestsVarianceFields = () =>
  new FeatureRequestsVarianceFieldsQueryBuilder();

export class FeatureVotesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureVotes> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeatureVotes, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureVotes = () => new FeatureVotesQueryBuilder();

export class FeatureVotesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureVotesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeatureVotesAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureVotesAggregate = () =>
  new FeatureVotesAggregateQueryBuilder();

export class FeatureVotesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureVotesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureVotesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureVotesAggregateFields = () =>
  new FeatureVotesAggregateFieldsQueryBuilder();

export class FeatureVotesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureVotesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeatureVotesAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureVotesAvgFields = () =>
  new FeatureVotesAvgFieldsQueryBuilder();

export class FeatureVotesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureVotesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeatureVotesMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureVotesMaxFields = () =>
  new FeatureVotesMaxFieldsQueryBuilder();

export class FeatureVotesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureVotesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeatureVotesMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureVotesMinFields = () =>
  new FeatureVotesMinFieldsQueryBuilder();

export class FeatureVotesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureVotesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureVotesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureVotesMutationResponse = () =>
  new FeatureVotesMutationResponseQueryBuilder();

export class FeatureVotesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureVotesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureVotesStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureVotesStddevFields = () =>
  new FeatureVotesStddevFieldsQueryBuilder();

export class FeatureVotesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureVotesStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureVotesStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureVotesStddevPopFields = () =>
  new FeatureVotesStddevPopFieldsQueryBuilder();

export class FeatureVotesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureVotesStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureVotesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureVotesStddevSampFields = () =>
  new FeatureVotesStddevSampFieldsQueryBuilder();

export class FeatureVotesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureVotesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeatureVotesSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureVotesSumFields = () =>
  new FeatureVotesSumFieldsQueryBuilder();

export class FeatureVotesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureVotesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureVotesVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureVotesVarPopFields = () =>
  new FeatureVotesVarPopFieldsQueryBuilder();

export class FeatureVotesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureVotesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureVotesVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureVotesVarSampFields = () =>
  new FeatureVotesVarSampFieldsQueryBuilder();

export class FeatureVotesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeatureVotesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeatureVotesVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeatureVotesVarianceFields = () =>
  new FeatureVotesVarianceFieldsQueryBuilder();

export class FeedCategoriesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedCategories> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedCategories, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedCategories = () => new FeedCategoriesQueryBuilder();

export class FeedCategoriesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedCategoriesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedCategoriesAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedCategoriesAggregate = () =>
  new FeedCategoriesAggregateQueryBuilder();

export class FeedCategoriesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedCategoriesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedCategoriesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedCategoriesAggregateFields = () =>
  new FeedCategoriesAggregateFieldsQueryBuilder();

export class FeedCategoriesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedCategoriesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedCategoriesAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedCategoriesAvgFields = () =>
  new FeedCategoriesAvgFieldsQueryBuilder();

export class FeedCategoriesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedCategoriesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedCategoriesMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedCategoriesMaxFields = () =>
  new FeedCategoriesMaxFieldsQueryBuilder();

export class FeedCategoriesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedCategoriesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedCategoriesMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedCategoriesMinFields = () =>
  new FeedCategoriesMinFieldsQueryBuilder();

export class FeedCategoriesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedCategoriesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedCategoriesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedCategoriesMutationResponse = () =>
  new FeedCategoriesMutationResponseQueryBuilder();

export class FeedCategoriesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedCategoriesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedCategoriesStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedCategoriesStddevFields = () =>
  new FeedCategoriesStddevFieldsQueryBuilder();

export class FeedCategoriesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedCategoriesStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedCategoriesStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedCategoriesStddevPopFields = () =>
  new FeedCategoriesStddevPopFieldsQueryBuilder();

export class FeedCategoriesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedCategoriesStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedCategoriesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedCategoriesStddevSampFields = () =>
  new FeedCategoriesStddevSampFieldsQueryBuilder();

export class FeedCategoriesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedCategoriesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedCategoriesSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedCategoriesSumFields = () =>
  new FeedCategoriesSumFieldsQueryBuilder();

export class FeedCategoriesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedCategoriesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedCategoriesVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedCategoriesVarPopFields = () =>
  new FeedCategoriesVarPopFieldsQueryBuilder();

export class FeedCategoriesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedCategoriesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedCategoriesVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedCategoriesVarSampFields = () =>
  new FeedCategoriesVarSampFieldsQueryBuilder();

export class FeedCategoriesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedCategoriesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedCategoriesVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedCategoriesVarianceFields = () =>
  new FeedCategoriesVarianceFieldsQueryBuilder();

export class FeedSourcesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedSources> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedSources, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedSources = () => new FeedSourcesQueryBuilder();

export class FeedSourcesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedSourcesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedSourcesAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedSourcesAggregate = () =>
  new FeedSourcesAggregateQueryBuilder();

export class FeedSourcesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedSourcesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedSourcesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedSourcesAggregateFields = () =>
  new FeedSourcesAggregateFieldsQueryBuilder();

export class FeedSourcesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedSourcesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedSourcesAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedSourcesAvgFields = () =>
  new FeedSourcesAvgFieldsQueryBuilder();

export class FeedSourcesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedSourcesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedSourcesMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedSourcesMaxFields = () =>
  new FeedSourcesMaxFieldsQueryBuilder();

export class FeedSourcesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedSourcesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedSourcesMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedSourcesMinFields = () =>
  new FeedSourcesMinFieldsQueryBuilder();

export class FeedSourcesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedSourcesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedSourcesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedSourcesMutationResponse = () =>
  new FeedSourcesMutationResponseQueryBuilder();

export class FeedSourcesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedSourcesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedSourcesStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedSourcesStddevFields = () =>
  new FeedSourcesStddevFieldsQueryBuilder();

export class FeedSourcesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedSourcesStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedSourcesStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedSourcesStddevPopFields = () =>
  new FeedSourcesStddevPopFieldsQueryBuilder();

export class FeedSourcesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedSourcesStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedSourcesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedSourcesStddevSampFields = () =>
  new FeedSourcesStddevSampFieldsQueryBuilder();

export class FeedSourcesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedSourcesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedSourcesSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedSourcesSumFields = () =>
  new FeedSourcesSumFieldsQueryBuilder();

export class FeedSourcesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedSourcesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedSourcesVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedSourcesVarPopFields = () =>
  new FeedSourcesVarPopFieldsQueryBuilder();

export class FeedSourcesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedSourcesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedSourcesVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedSourcesVarSampFields = () =>
  new FeedSourcesVarSampFieldsQueryBuilder();

export class FeedSourcesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedSourcesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedSourcesVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedSourcesVarianceFields = () =>
  new FeedSourcesVarianceFieldsQueryBuilder();

export class FeedbacksQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Feedbacks> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Feedbacks, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedbacks = () => new FeedbacksQueryBuilder();

export class FeedbacksAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedbacksAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedbacksAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedbacksAggregate = () =>
  new FeedbacksAggregateQueryBuilder();

export class FeedbacksAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedbacksAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedbacksAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedbacksAggregateFields = () =>
  new FeedbacksAggregateFieldsQueryBuilder();

export class FeedbacksAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedbacksAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedbacksAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedbacksAvgFields = () =>
  new FeedbacksAvgFieldsQueryBuilder();

export class FeedbacksMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedbacksMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedbacksMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedbacksMaxFields = () =>
  new FeedbacksMaxFieldsQueryBuilder();

export class FeedbacksMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedbacksMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedbacksMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedbacksMinFields = () =>
  new FeedbacksMinFieldsQueryBuilder();

export class FeedbacksMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedbacksMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedbacksMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedbacksMutationResponse = () =>
  new FeedbacksMutationResponseQueryBuilder();

export class FeedbacksStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedbacksStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedbacksStddevFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedbacksStddevFields = () =>
  new FeedbacksStddevFieldsQueryBuilder();

export class FeedbacksStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedbacksStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedbacksStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedbacksStddevPopFields = () =>
  new FeedbacksStddevPopFieldsQueryBuilder();

export class FeedbacksStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedbacksStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedbacksStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedbacksStddevSampFields = () =>
  new FeedbacksStddevSampFieldsQueryBuilder();

export class FeedbacksSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedbacksSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedbacksSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedbacksSumFields = () =>
  new FeedbacksSumFieldsQueryBuilder();

export class FeedbacksVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedbacksVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedbacksVarPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedbacksVarPopFields = () =>
  new FeedbacksVarPopFieldsQueryBuilder();

export class FeedbacksVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedbacksVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedbacksVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedbacksVarSampFields = () =>
  new FeedbacksVarSampFieldsQueryBuilder();

export class FeedbacksVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedbacksVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FeedbacksVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedbacksVarianceFields = () =>
  new FeedbacksVarianceFieldsQueryBuilder();

export class FeedsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Feeds> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Feeds, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeeds = () => new FeedsQueryBuilder();

export class FeedsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedsAggregate = () => new FeedsAggregateQueryBuilder();

export class FeedsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedsAggregateFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedsAggregateFields = () =>
  new FeedsAggregateFieldsQueryBuilder();

export class FeedsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedsMaxFields = () => new FeedsMaxFieldsQueryBuilder();

export class FeedsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedsMinFields = () => new FeedsMinFieldsQueryBuilder();

export class FeedsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FeedsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FeedsMutationResponse, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFeedsMutationResponse = () =>
  new FeedsMutationResponseQueryBuilder();

export class FollowsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Follows> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Follows, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFollows = () => new FollowsQueryBuilder();

export class FollowsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FollowsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FollowsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFollowsAggregate = () => new FollowsAggregateQueryBuilder();

export class FollowsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FollowsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FollowsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFollowsAggregateFields = () =>
  new FollowsAggregateFieldsQueryBuilder();

export class FollowsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FollowsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FollowsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFollowsMaxFields = () => new FollowsMaxFieldsQueryBuilder();

export class FollowsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FollowsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.FollowsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFollowsMinFields = () => new FollowsMinFieldsQueryBuilder();

export class FollowsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.FollowsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.FollowsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryFollowsMutationResponse = () =>
  new FollowsMutationResponseQueryBuilder();

export class MetricDefinitionsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.MetricDefinitions> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.MetricDefinitions, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryMetricDefinitions = () => new MetricDefinitionsQueryBuilder();

export class MetricDefinitionsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.MetricDefinitionsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.MetricDefinitionsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryMetricDefinitionsAggregate = () =>
  new MetricDefinitionsAggregateQueryBuilder();

export class MetricDefinitionsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.MetricDefinitionsAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.MetricDefinitionsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryMetricDefinitionsAggregateFields = () =>
  new MetricDefinitionsAggregateFieldsQueryBuilder();

export class MetricDefinitionsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.MetricDefinitionsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.MetricDefinitionsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryMetricDefinitionsAvgFields = () =>
  new MetricDefinitionsAvgFieldsQueryBuilder();

export class MetricDefinitionsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.MetricDefinitionsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.MetricDefinitionsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryMetricDefinitionsMaxFields = () =>
  new MetricDefinitionsMaxFieldsQueryBuilder();

export class MetricDefinitionsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.MetricDefinitionsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.MetricDefinitionsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryMetricDefinitionsMinFields = () =>
  new MetricDefinitionsMinFieldsQueryBuilder();

export class MetricDefinitionsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.MetricDefinitionsMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.MetricDefinitionsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryMetricDefinitionsMutationResponse = () =>
  new MetricDefinitionsMutationResponseQueryBuilder();

export class MetricDefinitionsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.MetricDefinitionsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.MetricDefinitionsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryMetricDefinitionsStddevFields = () =>
  new MetricDefinitionsStddevFieldsQueryBuilder();

export class MetricDefinitionsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.MetricDefinitionsStddevPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.MetricDefinitionsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryMetricDefinitionsStddevPopFields = () =>
  new MetricDefinitionsStddevPopFieldsQueryBuilder();

export class MetricDefinitionsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.MetricDefinitionsStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.MetricDefinitionsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryMetricDefinitionsStddevSampFields = () =>
  new MetricDefinitionsStddevSampFieldsQueryBuilder();

export class MetricDefinitionsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.MetricDefinitionsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.MetricDefinitionsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryMetricDefinitionsSumFields = () =>
  new MetricDefinitionsSumFieldsQueryBuilder();

export class MetricDefinitionsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.MetricDefinitionsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.MetricDefinitionsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryMetricDefinitionsVarPopFields = () =>
  new MetricDefinitionsVarPopFieldsQueryBuilder();

export class MetricDefinitionsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.MetricDefinitionsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.MetricDefinitionsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryMetricDefinitionsVarSampFields = () =>
  new MetricDefinitionsVarSampFieldsQueryBuilder();

export class MetricDefinitionsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.MetricDefinitionsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.MetricDefinitionsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryMetricDefinitionsVarianceFields = () =>
  new MetricDefinitionsVarianceFieldsQueryBuilder();

export class MutationRootQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.MutationRoot> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.MutationRoot, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryMutationRoot = () => new MutationRootQueryBuilder();

export class NewsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.News> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.News, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNews = () => new NewsQueryBuilder();

export class NewsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsAggregate = () => new NewsAggregateQueryBuilder();

export class NewsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsAggregateFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsAggregateFields = () =>
  new NewsAggregateFieldsQueryBuilder();

export class NewsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsAvgFields = () => new NewsAvgFieldsQueryBuilder();

export class NewsDetailsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsDetails> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsDetails, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsDetails = () => new NewsDetailsQueryBuilder();

export class NewsDetailsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsDetailsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsDetailsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsDetailsAggregate = () =>
  new NewsDetailsAggregateQueryBuilder();

export class NewsDetailsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsDetailsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsDetailsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsDetailsAggregateFields = () =>
  new NewsDetailsAggregateFieldsQueryBuilder();

export class NewsDetailsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsDetailsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsDetailsAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsDetailsAvgFields = () =>
  new NewsDetailsAvgFieldsQueryBuilder();

export class NewsDetailsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsDetailsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsDetailsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsDetailsMaxFields = () =>
  new NewsDetailsMaxFieldsQueryBuilder();

export class NewsDetailsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsDetailsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsDetailsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsDetailsMinFields = () =>
  new NewsDetailsMinFieldsQueryBuilder();

export class NewsDetailsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsDetailsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsDetailsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsDetailsStddevFields = () =>
  new NewsDetailsStddevFieldsQueryBuilder();

export class NewsDetailsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsDetailsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsDetailsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsDetailsStddevPopFields = () =>
  new NewsDetailsStddevPopFieldsQueryBuilder();

export class NewsDetailsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsDetailsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsDetailsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsDetailsStddevSampFields = () =>
  new NewsDetailsStddevSampFieldsQueryBuilder();

export class NewsDetailsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsDetailsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsDetailsSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsDetailsSumFields = () =>
  new NewsDetailsSumFieldsQueryBuilder();

export class NewsDetailsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsDetailsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsDetailsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsDetailsVarPopFields = () =>
  new NewsDetailsVarPopFieldsQueryBuilder();

export class NewsDetailsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsDetailsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsDetailsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsDetailsVarSampFields = () =>
  new NewsDetailsVarSampFieldsQueryBuilder();

export class NewsDetailsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsDetailsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsDetailsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsDetailsVarianceFields = () =>
  new NewsDetailsVarianceFieldsQueryBuilder();

export class NewsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsMaxFields = () => new NewsMaxFieldsQueryBuilder();

export class NewsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsMinFields = () => new NewsMinFieldsQueryBuilder();

export class NewsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsMutationResponse, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsMutationResponse = () =>
  new NewsMutationResponseQueryBuilder();

export class NewsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsStddevFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsStddevFields = () => new NewsStddevFieldsQueryBuilder();

export class NewsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsStddevPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsStddevPopFields = () =>
  new NewsStddevPopFieldsQueryBuilder();

export class NewsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsStddevSampFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsStddevSampFields = () =>
  new NewsStddevSampFieldsQueryBuilder();

export class NewsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsSumFields = () => new NewsSumFieldsQueryBuilder();

export class NewsSummariesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsSummaries> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsSummaries, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsSummaries = () => new NewsSummariesQueryBuilder();

export class NewsSummariesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsSummariesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsSummariesAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsSummariesAggregate = () =>
  new NewsSummariesAggregateQueryBuilder();

export class NewsSummariesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsSummariesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsSummariesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsSummariesAggregateFields = () =>
  new NewsSummariesAggregateFieldsQueryBuilder();

export class NewsSummariesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsSummariesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsSummariesAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsSummariesAvgFields = () =>
  new NewsSummariesAvgFieldsQueryBuilder();

export class NewsSummariesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsSummariesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsSummariesMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsSummariesMaxFields = () =>
  new NewsSummariesMaxFieldsQueryBuilder();

export class NewsSummariesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsSummariesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsSummariesMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsSummariesMinFields = () =>
  new NewsSummariesMinFieldsQueryBuilder();

export class NewsSummariesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsSummariesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsSummariesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsSummariesMutationResponse = () =>
  new NewsSummariesMutationResponseQueryBuilder();

export class NewsSummariesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsSummariesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsSummariesStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsSummariesStddevFields = () =>
  new NewsSummariesStddevFieldsQueryBuilder();

export class NewsSummariesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsSummariesStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsSummariesStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsSummariesStddevPopFields = () =>
  new NewsSummariesStddevPopFieldsQueryBuilder();

export class NewsSummariesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsSummariesStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsSummariesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsSummariesStddevSampFields = () =>
  new NewsSummariesStddevSampFieldsQueryBuilder();

export class NewsSummariesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsSummariesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsSummariesSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsSummariesSumFields = () =>
  new NewsSummariesSumFieldsQueryBuilder();

export class NewsSummariesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsSummariesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsSummariesVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsSummariesVarPopFields = () =>
  new NewsSummariesVarPopFieldsQueryBuilder();

export class NewsSummariesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsSummariesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsSummariesVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsSummariesVarSampFields = () =>
  new NewsSummariesVarSampFieldsQueryBuilder();

export class NewsSummariesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsSummariesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsSummariesVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsSummariesVarianceFields = () =>
  new NewsSummariesVarianceFieldsQueryBuilder();

export class NewsTagsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsTags> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsTags, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsTags = () => new NewsTagsQueryBuilder();

export class NewsTagsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsTagsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsTagsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsTagsAggregate = () => new NewsTagsAggregateQueryBuilder();

export class NewsTagsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsTagsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsTagsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsTagsAggregateFields = () =>
  new NewsTagsAggregateFieldsQueryBuilder();

export class NewsTagsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsTagsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsTagsAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsTagsAvgFields = () => new NewsTagsAvgFieldsQueryBuilder();

export class NewsTagsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsTagsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsTagsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsTagsMaxFields = () => new NewsTagsMaxFieldsQueryBuilder();

export class NewsTagsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsTagsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsTagsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsTagsMinFields = () => new NewsTagsMinFieldsQueryBuilder();

export class NewsTagsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsTagsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsTagsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsTagsMutationResponse = () =>
  new NewsTagsMutationResponseQueryBuilder();

export class NewsTagsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsTagsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsTagsStddevFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsTagsStddevFields = () =>
  new NewsTagsStddevFieldsQueryBuilder();

export class NewsTagsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsTagsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsTagsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsTagsStddevPopFields = () =>
  new NewsTagsStddevPopFieldsQueryBuilder();

export class NewsTagsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsTagsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsTagsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsTagsStddevSampFields = () =>
  new NewsTagsStddevSampFieldsQueryBuilder();

export class NewsTagsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsTagsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsTagsSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsTagsSumFields = () => new NewsTagsSumFieldsQueryBuilder();

export class NewsTagsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsTagsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsTagsVarPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsTagsVarPopFields = () =>
  new NewsTagsVarPopFieldsQueryBuilder();

export class NewsTagsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsTagsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsTagsVarSampFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsTagsVarSampFields = () =>
  new NewsTagsVarSampFieldsQueryBuilder();

export class NewsTagsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsTagsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewsTagsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsTagsVarianceFields = () =>
  new NewsTagsVarianceFieldsQueryBuilder();

export class NewsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsVarPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsVarPopFields = () => new NewsVarPopFieldsQueryBuilder();

export class NewsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsVarSampFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsVarSampFields = () => new NewsVarSampFieldsQueryBuilder();

export class NewsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewsVarianceFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsVarianceFields = () =>
  new NewsVarianceFieldsQueryBuilder();

export class NewslettersQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Newsletters> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Newsletters, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewsletters = () => new NewslettersQueryBuilder();

export class NewslettersAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewslettersAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewslettersAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewslettersAggregate = () =>
  new NewslettersAggregateQueryBuilder();

export class NewslettersAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewslettersAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewslettersAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewslettersAggregateFields = () =>
  new NewslettersAggregateFieldsQueryBuilder();

export class NewslettersMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewslettersMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewslettersMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewslettersMaxFields = () =>
  new NewslettersMaxFieldsQueryBuilder();

export class NewslettersMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewslettersMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.NewslettersMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewslettersMinFields = () =>
  new NewslettersMinFieldsQueryBuilder();

export class NewslettersMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.NewslettersMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.NewslettersMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryNewslettersMutationResponse = () =>
  new NewslettersMutationResponseQueryBuilder();

export class PaymentProvidersQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PaymentProviders> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.PaymentProviders, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPaymentProviders = () => new PaymentProvidersQueryBuilder();

export class PaymentProvidersAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PaymentProvidersAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PaymentProvidersAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPaymentProvidersAggregate = () =>
  new PaymentProvidersAggregateQueryBuilder();

export class PaymentProvidersAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PaymentProvidersAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PaymentProvidersAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPaymentProvidersAggregateFields = () =>
  new PaymentProvidersAggregateFieldsQueryBuilder();

export class PaymentProvidersAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PaymentProvidersAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PaymentProvidersAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPaymentProvidersAvgFields = () =>
  new PaymentProvidersAvgFieldsQueryBuilder();

export class PaymentProvidersMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PaymentProvidersMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PaymentProvidersMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPaymentProvidersMaxFields = () =>
  new PaymentProvidersMaxFieldsQueryBuilder();

export class PaymentProvidersMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PaymentProvidersMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PaymentProvidersMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPaymentProvidersMinFields = () =>
  new PaymentProvidersMinFieldsQueryBuilder();

export class PaymentProvidersMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PaymentProvidersMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PaymentProvidersMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPaymentProvidersMutationResponse = () =>
  new PaymentProvidersMutationResponseQueryBuilder();

export class PaymentProvidersStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PaymentProvidersStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PaymentProvidersStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPaymentProvidersStddevFields = () =>
  new PaymentProvidersStddevFieldsQueryBuilder();

export class PaymentProvidersStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PaymentProvidersStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PaymentProvidersStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPaymentProvidersStddevPopFields = () =>
  new PaymentProvidersStddevPopFieldsQueryBuilder();

export class PaymentProvidersStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PaymentProvidersStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PaymentProvidersStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPaymentProvidersStddevSampFields = () =>
  new PaymentProvidersStddevSampFieldsQueryBuilder();

export class PaymentProvidersSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PaymentProvidersSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PaymentProvidersSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPaymentProvidersSumFields = () =>
  new PaymentProvidersSumFieldsQueryBuilder();

export class PaymentProvidersVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PaymentProvidersVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PaymentProvidersVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPaymentProvidersVarPopFields = () =>
  new PaymentProvidersVarPopFieldsQueryBuilder();

export class PaymentProvidersVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PaymentProvidersVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PaymentProvidersVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPaymentProvidersVarSampFields = () =>
  new PaymentProvidersVarSampFieldsQueryBuilder();

export class PaymentProvidersVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PaymentProvidersVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PaymentProvidersVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPaymentProvidersVarianceFields = () =>
  new PaymentProvidersVarianceFieldsQueryBuilder();

export class PlanPermissionsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PlanPermissions> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.PlanPermissions, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPlanPermissions = () => new PlanPermissionsQueryBuilder();

export class PlanPermissionsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PlanPermissionsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PlanPermissionsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPlanPermissionsAggregate = () =>
  new PlanPermissionsAggregateQueryBuilder();

export class PlanPermissionsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PlanPermissionsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PlanPermissionsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPlanPermissionsAggregateFields = () =>
  new PlanPermissionsAggregateFieldsQueryBuilder();

export class PlanPermissionsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PlanPermissionsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PlanPermissionsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPlanPermissionsAvgFields = () =>
  new PlanPermissionsAvgFieldsQueryBuilder();

export class PlanPermissionsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PlanPermissionsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PlanPermissionsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPlanPermissionsMaxFields = () =>
  new PlanPermissionsMaxFieldsQueryBuilder();

export class PlanPermissionsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PlanPermissionsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PlanPermissionsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPlanPermissionsMinFields = () =>
  new PlanPermissionsMinFieldsQueryBuilder();

export class PlanPermissionsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PlanPermissionsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PlanPermissionsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPlanPermissionsMutationResponse = () =>
  new PlanPermissionsMutationResponseQueryBuilder();

export class PlanPermissionsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PlanPermissionsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PlanPermissionsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPlanPermissionsStddevFields = () =>
  new PlanPermissionsStddevFieldsQueryBuilder();

export class PlanPermissionsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PlanPermissionsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PlanPermissionsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPlanPermissionsStddevPopFields = () =>
  new PlanPermissionsStddevPopFieldsQueryBuilder();

export class PlanPermissionsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PlanPermissionsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PlanPermissionsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPlanPermissionsStddevSampFields = () =>
  new PlanPermissionsStddevSampFieldsQueryBuilder();

export class PlanPermissionsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PlanPermissionsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PlanPermissionsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPlanPermissionsSumFields = () =>
  new PlanPermissionsSumFieldsQueryBuilder();

export class PlanPermissionsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PlanPermissionsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PlanPermissionsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPlanPermissionsVarPopFields = () =>
  new PlanPermissionsVarPopFieldsQueryBuilder();

export class PlanPermissionsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PlanPermissionsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PlanPermissionsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPlanPermissionsVarSampFields = () =>
  new PlanPermissionsVarSampFieldsQueryBuilder();

export class PlanPermissionsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.PlanPermissionsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.PlanPermissionsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryPlanPermissionsVarianceFields = () =>
  new PlanPermissionsVarianceFieldsQueryBuilder();

export class QueryRootQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.QueryRoot> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.QueryRoot, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryQueryRoot = () => new QueryRootQueryBuilder();

export class RecentErrorsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RecentErrors> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.RecentErrors, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRecentErrors = () => new RecentErrorsQueryBuilder();

export class RecentErrorsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RecentErrorsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.RecentErrorsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRecentErrorsAggregate = () =>
  new RecentErrorsAggregateQueryBuilder();

export class RecentErrorsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RecentErrorsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RecentErrorsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRecentErrorsAggregateFields = () =>
  new RecentErrorsAggregateFieldsQueryBuilder();

export class RecentErrorsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RecentErrorsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.RecentErrorsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRecentErrorsMaxFields = () =>
  new RecentErrorsMaxFieldsQueryBuilder();

export class RecentErrorsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RecentErrorsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.RecentErrorsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRecentErrorsMinFields = () =>
  new RecentErrorsMinFieldsQueryBuilder();

export class RecentErrorsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RecentErrorsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RecentErrorsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRecentErrorsMutationResponse = () =>
  new RecentErrorsMutationResponseQueryBuilder();

export class ReferralStatsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralStats> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ReferralStats, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralStats = () => new ReferralStatsQueryBuilder();

export class ReferralStatsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralStatsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralStatsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralStatsAggregate = () =>
  new ReferralStatsAggregateQueryBuilder();

export class ReferralStatsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralStatsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralStatsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralStatsAggregateFields = () =>
  new ReferralStatsAggregateFieldsQueryBuilder();

export class ReferralStatsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralStatsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralStatsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralStatsAvgFields = () =>
  new ReferralStatsAvgFieldsQueryBuilder();

export class ReferralStatsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralStatsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralStatsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralStatsMaxFields = () =>
  new ReferralStatsMaxFieldsQueryBuilder();

export class ReferralStatsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralStatsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralStatsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralStatsMinFields = () =>
  new ReferralStatsMinFieldsQueryBuilder();

export class ReferralStatsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralStatsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralStatsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralStatsStddevFields = () =>
  new ReferralStatsStddevFieldsQueryBuilder();

export class ReferralStatsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralStatsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralStatsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralStatsStddevPopFields = () =>
  new ReferralStatsStddevPopFieldsQueryBuilder();

export class ReferralStatsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralStatsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralStatsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralStatsStddevSampFields = () =>
  new ReferralStatsStddevSampFieldsQueryBuilder();

export class ReferralStatsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralStatsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralStatsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralStatsSumFields = () =>
  new ReferralStatsSumFieldsQueryBuilder();

export class ReferralStatsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralStatsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralStatsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralStatsVarPopFields = () =>
  new ReferralStatsVarPopFieldsQueryBuilder();

export class ReferralStatsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralStatsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralStatsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralStatsVarSampFields = () =>
  new ReferralStatsVarSampFieldsQueryBuilder();

export class ReferralStatsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralStatsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralStatsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralStatsVarianceFields = () =>
  new ReferralStatsVarianceFieldsQueryBuilder();

export class ReferralsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Referrals> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Referrals, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrals = () => new ReferralsQueryBuilder();

export class ReferralsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ReferralsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralsAggregate = () =>
  new ReferralsAggregateQueryBuilder();

export class ReferralsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralsAggregateFields = () =>
  new ReferralsAggregateFieldsQueryBuilder();

export class ReferralsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ReferralsAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralsAvgFields = () =>
  new ReferralsAvgFieldsQueryBuilder();

export class ReferralsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ReferralsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralsMaxFields = () =>
  new ReferralsMaxFieldsQueryBuilder();

export class ReferralsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ReferralsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralsMinFields = () =>
  new ReferralsMinFieldsQueryBuilder();

export class ReferralsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralsMutationResponse = () =>
  new ReferralsMutationResponseQueryBuilder();

export class ReferralsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ReferralsStddevFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralsStddevFields = () =>
  new ReferralsStddevFieldsQueryBuilder();

export class ReferralsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralsStddevPopFields = () =>
  new ReferralsStddevPopFieldsQueryBuilder();

export class ReferralsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralsStddevSampFields = () =>
  new ReferralsStddevSampFieldsQueryBuilder();

export class ReferralsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ReferralsSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralsSumFields = () =>
  new ReferralsSumFieldsQueryBuilder();

export class ReferralsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ReferralsVarPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralsVarPopFields = () =>
  new ReferralsVarPopFieldsQueryBuilder();

export class ReferralsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralsVarSampFields = () =>
  new ReferralsVarSampFieldsQueryBuilder();

export class ReferralsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferralsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferralsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferralsVarianceFields = () =>
  new ReferralsVarianceFieldsQueryBuilder();

export class ReferrerBlocksQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerBlocks> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ReferrerBlocks, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerBlocks = () => new ReferrerBlocksQueryBuilder();

export class ReferrerBlocksAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerBlocksAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerBlocksAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerBlocksAggregate = () =>
  new ReferrerBlocksAggregateQueryBuilder();

export class ReferrerBlocksAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerBlocksAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerBlocksAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerBlocksAggregateFields = () =>
  new ReferrerBlocksAggregateFieldsQueryBuilder();

export class ReferrerBlocksMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerBlocksMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerBlocksMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerBlocksMaxFields = () =>
  new ReferrerBlocksMaxFieldsQueryBuilder();

export class ReferrerBlocksMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerBlocksMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerBlocksMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerBlocksMinFields = () =>
  new ReferrerBlocksMinFieldsQueryBuilder();

export class ReferrerBlocksMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerBlocksMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerBlocksMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerBlocksMutationResponse = () =>
  new ReferrerBlocksMutationResponseQueryBuilder();

export class ReferrerRiskMetricsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerRiskMetrics> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ReferrerRiskMetrics, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerRiskMetrics = () =>
  new ReferrerRiskMetricsQueryBuilder();

export class ReferrerRiskMetricsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerRiskMetricsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerRiskMetricsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerRiskMetricsAggregate = () =>
  new ReferrerRiskMetricsAggregateQueryBuilder();

export class ReferrerRiskMetricsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerRiskMetricsAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerRiskMetricsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerRiskMetricsAggregateFields = () =>
  new ReferrerRiskMetricsAggregateFieldsQueryBuilder();

export class ReferrerRiskMetricsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerRiskMetricsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerRiskMetricsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerRiskMetricsAvgFields = () =>
  new ReferrerRiskMetricsAvgFieldsQueryBuilder();

export class ReferrerRiskMetricsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerRiskMetricsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerRiskMetricsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerRiskMetricsMaxFields = () =>
  new ReferrerRiskMetricsMaxFieldsQueryBuilder();

export class ReferrerRiskMetricsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerRiskMetricsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerRiskMetricsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerRiskMetricsMinFields = () =>
  new ReferrerRiskMetricsMinFieldsQueryBuilder();

export class ReferrerRiskMetricsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerRiskMetricsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerRiskMetricsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerRiskMetricsStddevFields = () =>
  new ReferrerRiskMetricsStddevFieldsQueryBuilder();

export class ReferrerRiskMetricsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerRiskMetricsStddevPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerRiskMetricsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerRiskMetricsStddevPopFields = () =>
  new ReferrerRiskMetricsStddevPopFieldsQueryBuilder();

export class ReferrerRiskMetricsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerRiskMetricsStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerRiskMetricsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerRiskMetricsStddevSampFields = () =>
  new ReferrerRiskMetricsStddevSampFieldsQueryBuilder();

export class ReferrerRiskMetricsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerRiskMetricsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerRiskMetricsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerRiskMetricsSumFields = () =>
  new ReferrerRiskMetricsSumFieldsQueryBuilder();

export class ReferrerRiskMetricsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerRiskMetricsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerRiskMetricsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerRiskMetricsVarPopFields = () =>
  new ReferrerRiskMetricsVarPopFieldsQueryBuilder();

export class ReferrerRiskMetricsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerRiskMetricsVarSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerRiskMetricsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerRiskMetricsVarSampFields = () =>
  new ReferrerRiskMetricsVarSampFieldsQueryBuilder();

export class ReferrerRiskMetricsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ReferrerRiskMetricsVarianceFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ReferrerRiskMetricsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryReferrerRiskMetricsVarianceFields = () =>
  new ReferrerRiskMetricsVarianceFieldsQueryBuilder();

export class ResearchQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Research> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Research, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearch = () => new ResearchQueryBuilder();

export class ResearchAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResearchAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchAggregate = () => new ResearchAggregateQueryBuilder();

export class ResearchAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchAggregateFields = () =>
  new ResearchAggregateFieldsQueryBuilder();

export class ResearchAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResearchAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchAvgFields = () => new ResearchAvgFieldsQueryBuilder();

export class ResearchEmbeddingsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchEmbeddings> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResearchEmbeddings, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchEmbeddings = () =>
  new ResearchEmbeddingsQueryBuilder();

export class ResearchEmbeddingsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchEmbeddingsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchEmbeddingsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchEmbeddingsAggregate = () =>
  new ResearchEmbeddingsAggregateQueryBuilder();

export class ResearchEmbeddingsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchEmbeddingsAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchEmbeddingsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchEmbeddingsAggregateFields = () =>
  new ResearchEmbeddingsAggregateFieldsQueryBuilder();

export class ResearchEmbeddingsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchEmbeddingsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchEmbeddingsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchEmbeddingsAvgFields = () =>
  new ResearchEmbeddingsAvgFieldsQueryBuilder();

export class ResearchEmbeddingsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchEmbeddingsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchEmbeddingsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchEmbeddingsMaxFields = () =>
  new ResearchEmbeddingsMaxFieldsQueryBuilder();

export class ResearchEmbeddingsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchEmbeddingsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchEmbeddingsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchEmbeddingsMinFields = () =>
  new ResearchEmbeddingsMinFieldsQueryBuilder();

export class ResearchEmbeddingsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchEmbeddingsMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchEmbeddingsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchEmbeddingsMutationResponse = () =>
  new ResearchEmbeddingsMutationResponseQueryBuilder();

export class ResearchEmbeddingsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchEmbeddingsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchEmbeddingsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchEmbeddingsStddevFields = () =>
  new ResearchEmbeddingsStddevFieldsQueryBuilder();

export class ResearchEmbeddingsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchEmbeddingsStddevPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchEmbeddingsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchEmbeddingsStddevPopFields = () =>
  new ResearchEmbeddingsStddevPopFieldsQueryBuilder();

export class ResearchEmbeddingsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchEmbeddingsStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchEmbeddingsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchEmbeddingsStddevSampFields = () =>
  new ResearchEmbeddingsStddevSampFieldsQueryBuilder();

export class ResearchEmbeddingsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchEmbeddingsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchEmbeddingsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchEmbeddingsSumFields = () =>
  new ResearchEmbeddingsSumFieldsQueryBuilder();

export class ResearchEmbeddingsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchEmbeddingsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchEmbeddingsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchEmbeddingsVarPopFields = () =>
  new ResearchEmbeddingsVarPopFieldsQueryBuilder();

export class ResearchEmbeddingsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchEmbeddingsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchEmbeddingsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchEmbeddingsVarSampFields = () =>
  new ResearchEmbeddingsVarSampFieldsQueryBuilder();

export class ResearchEmbeddingsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchEmbeddingsVarianceFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchEmbeddingsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchEmbeddingsVarianceFields = () =>
  new ResearchEmbeddingsVarianceFieldsQueryBuilder();

export class ResearchMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResearchMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchMaxFields = () => new ResearchMaxFieldsQueryBuilder();

export class ResearchMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResearchMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchMinFields = () => new ResearchMinFieldsQueryBuilder();

export class ResearchMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchMutationResponse = () =>
  new ResearchMutationResponseQueryBuilder();

export class ResearchStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResearchStddevFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchStddevFields = () =>
  new ResearchStddevFieldsQueryBuilder();

export class ResearchStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchStddevPopFields = () =>
  new ResearchStddevPopFieldsQueryBuilder();

export class ResearchStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchStddevSampFields = () =>
  new ResearchStddevSampFieldsQueryBuilder();

export class ResearchSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResearchSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchSumFields = () => new ResearchSumFieldsQueryBuilder();

export class ResearchVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResearchVarPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchVarPopFields = () =>
  new ResearchVarPopFieldsQueryBuilder();

export class ResearchVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResearchVarSampFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchVarSampFields = () =>
  new ResearchVarSampFieldsQueryBuilder();

export class ResearchVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResearchVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResearchVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResearchVarianceFields = () =>
  new ResearchVarianceFieldsQueryBuilder();

export class ResponsesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Responses> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Responses, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResponses = () => new ResponsesQueryBuilder();

export class ResponsesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResponsesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResponsesAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResponsesAggregate = () =>
  new ResponsesAggregateQueryBuilder();

export class ResponsesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResponsesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResponsesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResponsesAggregateFields = () =>
  new ResponsesAggregateFieldsQueryBuilder();

export class ResponsesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResponsesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResponsesAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResponsesAvgFields = () =>
  new ResponsesAvgFieldsQueryBuilder();

export class ResponsesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResponsesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResponsesMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResponsesMaxFields = () =>
  new ResponsesMaxFieldsQueryBuilder();

export class ResponsesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResponsesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResponsesMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResponsesMinFields = () =>
  new ResponsesMinFieldsQueryBuilder();

export class ResponsesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResponsesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResponsesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResponsesMutationResponse = () =>
  new ResponsesMutationResponseQueryBuilder();

export class ResponsesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResponsesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResponsesStddevFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResponsesStddevFields = () =>
  new ResponsesStddevFieldsQueryBuilder();

export class ResponsesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResponsesStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResponsesStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResponsesStddevPopFields = () =>
  new ResponsesStddevPopFieldsQueryBuilder();

export class ResponsesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResponsesStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResponsesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResponsesStddevSampFields = () =>
  new ResponsesStddevSampFieldsQueryBuilder();

export class ResponsesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResponsesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResponsesSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResponsesSumFields = () =>
  new ResponsesSumFieldsQueryBuilder();

export class ResponsesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResponsesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ResponsesVarPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResponsesVarPopFields = () =>
  new ResponsesVarPopFieldsQueryBuilder();

export class ResponsesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResponsesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResponsesVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResponsesVarSampFields = () =>
  new ResponsesVarSampFieldsQueryBuilder();

export class ResponsesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ResponsesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ResponsesVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryResponsesVarianceFields = () =>
  new ResponsesVarianceFieldsQueryBuilder();

export class RoleHierarchyQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RoleHierarchy> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.RoleHierarchy, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRoleHierarchy = () => new RoleHierarchyQueryBuilder();

export class RoleHierarchyAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RoleHierarchyAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RoleHierarchyAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRoleHierarchyAggregate = () =>
  new RoleHierarchyAggregateQueryBuilder();

export class RoleHierarchyAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RoleHierarchyAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RoleHierarchyAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRoleHierarchyAggregateFields = () =>
  new RoleHierarchyAggregateFieldsQueryBuilder();

export class RoleHierarchyMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RoleHierarchyMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RoleHierarchyMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRoleHierarchyMaxFields = () =>
  new RoleHierarchyMaxFieldsQueryBuilder();

export class RoleHierarchyMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RoleHierarchyMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RoleHierarchyMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRoleHierarchyMinFields = () =>
  new RoleHierarchyMinFieldsQueryBuilder();

export class RoleHierarchyMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RoleHierarchyMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RoleHierarchyMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRoleHierarchyMutationResponse = () =>
  new RoleHierarchyMutationResponseQueryBuilder();

export class RolePermissionsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissions> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.RolePermissions, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissions = () => new RolePermissionsQueryBuilder();

export class RolePermissionsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsAggregate = () =>
  new RolePermissionsAggregateQueryBuilder();

export class RolePermissionsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsAggregateFields = () =>
  new RolePermissionsAggregateFieldsQueryBuilder();

export class RolePermissionsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsAvgFields = () =>
  new RolePermissionsAvgFieldsQueryBuilder();

export class RolePermissionsMaterializedQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsMaterialized> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsMaterialized,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsMaterialized = () =>
  new RolePermissionsMaterializedQueryBuilder();

export class RolePermissionsMaterializedAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsMaterializedAggregate> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsMaterializedAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsMaterializedAggregate = () =>
  new RolePermissionsMaterializedAggregateQueryBuilder();

export class RolePermissionsMaterializedAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsMaterializedAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsMaterializedAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsMaterializedAggregateFields = () =>
  new RolePermissionsMaterializedAggregateFieldsQueryBuilder();

export class RolePermissionsMaterializedMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsMaterializedMaxFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsMaterializedMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsMaterializedMaxFields = () =>
  new RolePermissionsMaterializedMaxFieldsQueryBuilder();

export class RolePermissionsMaterializedMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsMaterializedMinFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsMaterializedMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsMaterializedMinFields = () =>
  new RolePermissionsMaterializedMinFieldsQueryBuilder();

export class RolePermissionsMaterializedMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsMaterializedMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsMaterializedMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsMaterializedMutationResponse = () =>
  new RolePermissionsMaterializedMutationResponseQueryBuilder();

export class RolePermissionsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsMaxFields = () =>
  new RolePermissionsMaxFieldsQueryBuilder();

export class RolePermissionsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsMinFields = () =>
  new RolePermissionsMinFieldsQueryBuilder();

export class RolePermissionsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsMutationResponse = () =>
  new RolePermissionsMutationResponseQueryBuilder();

export class RolePermissionsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsStddevFields = () =>
  new RolePermissionsStddevFieldsQueryBuilder();

export class RolePermissionsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsStddevPopFields = () =>
  new RolePermissionsStddevPopFieldsQueryBuilder();

export class RolePermissionsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsStddevSampFields = () =>
  new RolePermissionsStddevSampFieldsQueryBuilder();

export class RolePermissionsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsSumFields = () =>
  new RolePermissionsSumFieldsQueryBuilder();

export class RolePermissionsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsVarPopFields = () =>
  new RolePermissionsVarPopFieldsQueryBuilder();

export class RolePermissionsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsVarSampFields = () =>
  new RolePermissionsVarSampFieldsQueryBuilder();

export class RolePermissionsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.RolePermissionsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.RolePermissionsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryRolePermissionsVarianceFields = () =>
  new RolePermissionsVarianceFieldsQueryBuilder();

export class ScoringWeightsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ScoringWeights> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.ScoringWeights, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryScoringWeights = () => new ScoringWeightsQueryBuilder();

export class ScoringWeightsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ScoringWeightsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ScoringWeightsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryScoringWeightsAggregate = () =>
  new ScoringWeightsAggregateQueryBuilder();

export class ScoringWeightsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ScoringWeightsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ScoringWeightsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryScoringWeightsAggregateFields = () =>
  new ScoringWeightsAggregateFieldsQueryBuilder();

export class ScoringWeightsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ScoringWeightsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ScoringWeightsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryScoringWeightsAvgFields = () =>
  new ScoringWeightsAvgFieldsQueryBuilder();

export class ScoringWeightsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ScoringWeightsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ScoringWeightsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryScoringWeightsMaxFields = () =>
  new ScoringWeightsMaxFieldsQueryBuilder();

export class ScoringWeightsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ScoringWeightsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ScoringWeightsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryScoringWeightsMinFields = () =>
  new ScoringWeightsMinFieldsQueryBuilder();

export class ScoringWeightsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ScoringWeightsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ScoringWeightsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryScoringWeightsMutationResponse = () =>
  new ScoringWeightsMutationResponseQueryBuilder();

export class ScoringWeightsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ScoringWeightsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ScoringWeightsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryScoringWeightsStddevFields = () =>
  new ScoringWeightsStddevFieldsQueryBuilder();

export class ScoringWeightsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ScoringWeightsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ScoringWeightsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryScoringWeightsStddevPopFields = () =>
  new ScoringWeightsStddevPopFieldsQueryBuilder();

export class ScoringWeightsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ScoringWeightsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ScoringWeightsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryScoringWeightsStddevSampFields = () =>
  new ScoringWeightsStddevSampFieldsQueryBuilder();

export class ScoringWeightsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ScoringWeightsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ScoringWeightsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryScoringWeightsSumFields = () =>
  new ScoringWeightsSumFieldsQueryBuilder();

export class ScoringWeightsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ScoringWeightsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ScoringWeightsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryScoringWeightsVarPopFields = () =>
  new ScoringWeightsVarPopFieldsQueryBuilder();

export class ScoringWeightsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ScoringWeightsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ScoringWeightsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryScoringWeightsVarSampFields = () =>
  new ScoringWeightsVarSampFieldsQueryBuilder();

export class ScoringWeightsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.ScoringWeightsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.ScoringWeightsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryScoringWeightsVarianceFields = () =>
  new ScoringWeightsVarianceFieldsQueryBuilder();

export class SearchesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Searches> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Searches, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySearches = () => new SearchesQueryBuilder();

export class SearchesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SearchesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SearchesAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySearchesAggregate = () => new SearchesAggregateQueryBuilder();

export class SearchesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SearchesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SearchesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySearchesAggregateFields = () =>
  new SearchesAggregateFieldsQueryBuilder();

export class SearchesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SearchesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SearchesAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySearchesAvgFields = () => new SearchesAvgFieldsQueryBuilder();

export class SearchesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SearchesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SearchesMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySearchesMaxFields = () => new SearchesMaxFieldsQueryBuilder();

export class SearchesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SearchesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SearchesMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySearchesMinFields = () => new SearchesMinFieldsQueryBuilder();

export class SearchesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SearchesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SearchesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySearchesMutationResponse = () =>
  new SearchesMutationResponseQueryBuilder();

export class SearchesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SearchesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SearchesStddevFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySearchesStddevFields = () =>
  new SearchesStddevFieldsQueryBuilder();

export class SearchesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SearchesStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SearchesStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySearchesStddevPopFields = () =>
  new SearchesStddevPopFieldsQueryBuilder();

export class SearchesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SearchesStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SearchesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySearchesStddevSampFields = () =>
  new SearchesStddevSampFieldsQueryBuilder();

export class SearchesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SearchesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SearchesSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySearchesSumFields = () => new SearchesSumFieldsQueryBuilder();

export class SearchesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SearchesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SearchesVarPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySearchesVarPopFields = () =>
  new SearchesVarPopFieldsQueryBuilder();

export class SearchesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SearchesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SearchesVarSampFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySearchesVarSampFields = () =>
  new SearchesVarSampFieldsQueryBuilder();

export class SearchesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SearchesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SearchesVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySearchesVarianceFields = () =>
  new SearchesVarianceFieldsQueryBuilder();

export class SecurityMetricsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SecurityMetrics> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SecurityMetrics, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySecurityMetrics = () => new SecurityMetricsQueryBuilder();

export class SecurityMetricsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SecurityMetricsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SecurityMetricsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySecurityMetricsAggregate = () =>
  new SecurityMetricsAggregateQueryBuilder();

export class SecurityMetricsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SecurityMetricsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SecurityMetricsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySecurityMetricsAggregateFields = () =>
  new SecurityMetricsAggregateFieldsQueryBuilder();

export class SecurityMetricsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SecurityMetricsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SecurityMetricsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySecurityMetricsAvgFields = () =>
  new SecurityMetricsAvgFieldsQueryBuilder();

export class SecurityMetricsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SecurityMetricsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SecurityMetricsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySecurityMetricsMaxFields = () =>
  new SecurityMetricsMaxFieldsQueryBuilder();

export class SecurityMetricsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SecurityMetricsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SecurityMetricsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySecurityMetricsMinFields = () =>
  new SecurityMetricsMinFieldsQueryBuilder();

export class SecurityMetricsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SecurityMetricsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SecurityMetricsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySecurityMetricsStddevFields = () =>
  new SecurityMetricsStddevFieldsQueryBuilder();

export class SecurityMetricsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SecurityMetricsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SecurityMetricsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySecurityMetricsStddevPopFields = () =>
  new SecurityMetricsStddevPopFieldsQueryBuilder();

export class SecurityMetricsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SecurityMetricsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SecurityMetricsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySecurityMetricsStddevSampFields = () =>
  new SecurityMetricsStddevSampFieldsQueryBuilder();

export class SecurityMetricsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SecurityMetricsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SecurityMetricsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySecurityMetricsSumFields = () =>
  new SecurityMetricsSumFieldsQueryBuilder();

export class SecurityMetricsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SecurityMetricsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SecurityMetricsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySecurityMetricsVarPopFields = () =>
  new SecurityMetricsVarPopFieldsQueryBuilder();

export class SecurityMetricsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SecurityMetricsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SecurityMetricsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySecurityMetricsVarSampFields = () =>
  new SecurityMetricsVarSampFieldsQueryBuilder();

export class SecurityMetricsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SecurityMetricsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SecurityMetricsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySecurityMetricsVarianceFields = () =>
  new SecurityMetricsVarianceFieldsQueryBuilder();

export class SlowQueryPatternsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SlowQueryPatterns> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SlowQueryPatterns, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySlowQueryPatterns = () => new SlowQueryPatternsQueryBuilder();

export class SlowQueryPatternsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SlowQueryPatternsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SlowQueryPatternsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySlowQueryPatternsAggregate = () =>
  new SlowQueryPatternsAggregateQueryBuilder();

export class SlowQueryPatternsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SlowQueryPatternsAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SlowQueryPatternsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySlowQueryPatternsAggregateFields = () =>
  new SlowQueryPatternsAggregateFieldsQueryBuilder();

export class SlowQueryPatternsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SlowQueryPatternsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SlowQueryPatternsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySlowQueryPatternsAvgFields = () =>
  new SlowQueryPatternsAvgFieldsQueryBuilder();

export class SlowQueryPatternsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SlowQueryPatternsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SlowQueryPatternsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySlowQueryPatternsMaxFields = () =>
  new SlowQueryPatternsMaxFieldsQueryBuilder();

export class SlowQueryPatternsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SlowQueryPatternsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SlowQueryPatternsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySlowQueryPatternsMinFields = () =>
  new SlowQueryPatternsMinFieldsQueryBuilder();

export class SlowQueryPatternsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SlowQueryPatternsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SlowQueryPatternsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySlowQueryPatternsStddevFields = () =>
  new SlowQueryPatternsStddevFieldsQueryBuilder();

export class SlowQueryPatternsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SlowQueryPatternsStddevPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SlowQueryPatternsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySlowQueryPatternsStddevPopFields = () =>
  new SlowQueryPatternsStddevPopFieldsQueryBuilder();

export class SlowQueryPatternsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SlowQueryPatternsStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SlowQueryPatternsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySlowQueryPatternsStddevSampFields = () =>
  new SlowQueryPatternsStddevSampFieldsQueryBuilder();

export class SlowQueryPatternsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SlowQueryPatternsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SlowQueryPatternsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySlowQueryPatternsSumFields = () =>
  new SlowQueryPatternsSumFieldsQueryBuilder();

export class SlowQueryPatternsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SlowQueryPatternsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SlowQueryPatternsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySlowQueryPatternsVarPopFields = () =>
  new SlowQueryPatternsVarPopFieldsQueryBuilder();

export class SlowQueryPatternsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SlowQueryPatternsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SlowQueryPatternsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySlowQueryPatternsVarSampFields = () =>
  new SlowQueryPatternsVarSampFieldsQueryBuilder();

export class SlowQueryPatternsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SlowQueryPatternsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SlowQueryPatternsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySlowQueryPatternsVarianceFields = () =>
  new SlowQueryPatternsVarianceFieldsQueryBuilder();

export class SocialMediaQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SocialMedia> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SocialMedia, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySocialMedia = () => new SocialMediaQueryBuilder();

export class SocialMediaAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SocialMediaAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SocialMediaAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySocialMediaAggregate = () =>
  new SocialMediaAggregateQueryBuilder();

export class SocialMediaAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SocialMediaAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SocialMediaAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySocialMediaAggregateFields = () =>
  new SocialMediaAggregateFieldsQueryBuilder();

export class SocialMediaAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SocialMediaAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SocialMediaAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySocialMediaAvgFields = () =>
  new SocialMediaAvgFieldsQueryBuilder();

export class SocialMediaMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SocialMediaMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SocialMediaMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySocialMediaMaxFields = () =>
  new SocialMediaMaxFieldsQueryBuilder();

export class SocialMediaMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SocialMediaMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SocialMediaMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySocialMediaMinFields = () =>
  new SocialMediaMinFieldsQueryBuilder();

export class SocialMediaMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SocialMediaMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SocialMediaMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySocialMediaMutationResponse = () =>
  new SocialMediaMutationResponseQueryBuilder();

export class SocialMediaStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SocialMediaStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SocialMediaStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySocialMediaStddevFields = () =>
  new SocialMediaStddevFieldsQueryBuilder();

export class SocialMediaStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SocialMediaStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SocialMediaStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySocialMediaStddevPopFields = () =>
  new SocialMediaStddevPopFieldsQueryBuilder();

export class SocialMediaStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SocialMediaStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SocialMediaStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySocialMediaStddevSampFields = () =>
  new SocialMediaStddevSampFieldsQueryBuilder();

export class SocialMediaSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SocialMediaSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SocialMediaSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySocialMediaSumFields = () =>
  new SocialMediaSumFieldsQueryBuilder();

export class SocialMediaVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SocialMediaVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SocialMediaVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySocialMediaVarPopFields = () =>
  new SocialMediaVarPopFieldsQueryBuilder();

export class SocialMediaVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SocialMediaVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SocialMediaVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySocialMediaVarSampFields = () =>
  new SocialMediaVarSampFieldsQueryBuilder();

export class SocialMediaVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SocialMediaVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SocialMediaVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySocialMediaVarianceFields = () =>
  new SocialMediaVarianceFieldsQueryBuilder();

export class SpiderMetricsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SpiderMetrics> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SpiderMetrics, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySpiderMetrics = () => new SpiderMetricsQueryBuilder();

export class SpiderMetricsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SpiderMetricsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SpiderMetricsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySpiderMetricsAggregate = () =>
  new SpiderMetricsAggregateQueryBuilder();

export class SpiderMetricsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SpiderMetricsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SpiderMetricsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySpiderMetricsAggregateFields = () =>
  new SpiderMetricsAggregateFieldsQueryBuilder();

export class SpiderMetricsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SpiderMetricsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SpiderMetricsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySpiderMetricsAvgFields = () =>
  new SpiderMetricsAvgFieldsQueryBuilder();

export class SpiderMetricsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SpiderMetricsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SpiderMetricsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySpiderMetricsMaxFields = () =>
  new SpiderMetricsMaxFieldsQueryBuilder();

export class SpiderMetricsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SpiderMetricsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SpiderMetricsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySpiderMetricsMinFields = () =>
  new SpiderMetricsMinFieldsQueryBuilder();

export class SpiderMetricsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SpiderMetricsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SpiderMetricsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySpiderMetricsMutationResponse = () =>
  new SpiderMetricsMutationResponseQueryBuilder();

export class SpiderMetricsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SpiderMetricsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SpiderMetricsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySpiderMetricsStddevFields = () =>
  new SpiderMetricsStddevFieldsQueryBuilder();

export class SpiderMetricsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SpiderMetricsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SpiderMetricsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySpiderMetricsStddevPopFields = () =>
  new SpiderMetricsStddevPopFieldsQueryBuilder();

export class SpiderMetricsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SpiderMetricsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SpiderMetricsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySpiderMetricsStddevSampFields = () =>
  new SpiderMetricsStddevSampFieldsQueryBuilder();

export class SpiderMetricsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SpiderMetricsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SpiderMetricsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySpiderMetricsSumFields = () =>
  new SpiderMetricsSumFieldsQueryBuilder();

export class SpiderMetricsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SpiderMetricsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SpiderMetricsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySpiderMetricsVarPopFields = () =>
  new SpiderMetricsVarPopFieldsQueryBuilder();

export class SpiderMetricsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SpiderMetricsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SpiderMetricsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySpiderMetricsVarSampFields = () =>
  new SpiderMetricsVarSampFieldsQueryBuilder();

export class SpiderMetricsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SpiderMetricsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.SpiderMetricsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySpiderMetricsVarianceFields = () =>
  new SpiderMetricsVarianceFieldsQueryBuilder();

export class StrapiMigrationsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrations> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.StrapiMigrations, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrations = () => new StrapiMigrationsQueryBuilder();

export class StrapiMigrationsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsAggregate = () =>
  new StrapiMigrationsAggregateQueryBuilder();

export class StrapiMigrationsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsAggregateFields = () =>
  new StrapiMigrationsAggregateFieldsQueryBuilder();

export class StrapiMigrationsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsAvgFields = () =>
  new StrapiMigrationsAvgFieldsQueryBuilder();

export class StrapiMigrationsInternalQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsInternal> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsInternal,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsInternal = () =>
  new StrapiMigrationsInternalQueryBuilder();

export class StrapiMigrationsInternalAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsInternalAggregate> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsInternalAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsInternalAggregate = () =>
  new StrapiMigrationsInternalAggregateQueryBuilder();

export class StrapiMigrationsInternalAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsInternalAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsInternalAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsInternalAggregateFields = () =>
  new StrapiMigrationsInternalAggregateFieldsQueryBuilder();

export class StrapiMigrationsInternalAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsInternalAvgFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsInternalAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsInternalAvgFields = () =>
  new StrapiMigrationsInternalAvgFieldsQueryBuilder();

export class StrapiMigrationsInternalMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsInternalMaxFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsInternalMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsInternalMaxFields = () =>
  new StrapiMigrationsInternalMaxFieldsQueryBuilder();

export class StrapiMigrationsInternalMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsInternalMinFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsInternalMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsInternalMinFields = () =>
  new StrapiMigrationsInternalMinFieldsQueryBuilder();

export class StrapiMigrationsInternalMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsInternalMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsInternalMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsInternalMutationResponse = () =>
  new StrapiMigrationsInternalMutationResponseQueryBuilder();

export class StrapiMigrationsInternalStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsInternalStddevFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsInternalStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsInternalStddevFields = () =>
  new StrapiMigrationsInternalStddevFieldsQueryBuilder();

export class StrapiMigrationsInternalStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsInternalStddevPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsInternalStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsInternalStddevPopFields = () =>
  new StrapiMigrationsInternalStddevPopFieldsQueryBuilder();

export class StrapiMigrationsInternalStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsInternalStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsInternalStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsInternalStddevSampFields = () =>
  new StrapiMigrationsInternalStddevSampFieldsQueryBuilder();

export class StrapiMigrationsInternalSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsInternalSumFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsInternalSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsInternalSumFields = () =>
  new StrapiMigrationsInternalSumFieldsQueryBuilder();

export class StrapiMigrationsInternalVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsInternalVarPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsInternalVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsInternalVarPopFields = () =>
  new StrapiMigrationsInternalVarPopFieldsQueryBuilder();

export class StrapiMigrationsInternalVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsInternalVarSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsInternalVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsInternalVarSampFields = () =>
  new StrapiMigrationsInternalVarSampFieldsQueryBuilder();

export class StrapiMigrationsInternalVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsInternalVarianceFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsInternalVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsInternalVarianceFields = () =>
  new StrapiMigrationsInternalVarianceFieldsQueryBuilder();

export class StrapiMigrationsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsMaxFields = () =>
  new StrapiMigrationsMaxFieldsQueryBuilder();

export class StrapiMigrationsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsMinFields = () =>
  new StrapiMigrationsMinFieldsQueryBuilder();

export class StrapiMigrationsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsMutationResponse = () =>
  new StrapiMigrationsMutationResponseQueryBuilder();

export class StrapiMigrationsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsStddevFields = () =>
  new StrapiMigrationsStddevFieldsQueryBuilder();

export class StrapiMigrationsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsStddevPopFields = () =>
  new StrapiMigrationsStddevPopFieldsQueryBuilder();

export class StrapiMigrationsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsStddevSampFields = () =>
  new StrapiMigrationsStddevSampFieldsQueryBuilder();

export class StrapiMigrationsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsSumFields = () =>
  new StrapiMigrationsSumFieldsQueryBuilder();

export class StrapiMigrationsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsVarPopFields = () =>
  new StrapiMigrationsVarPopFieldsQueryBuilder();

export class StrapiMigrationsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsVarSampFields = () =>
  new StrapiMigrationsVarSampFieldsQueryBuilder();

export class StrapiMigrationsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.StrapiMigrationsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.StrapiMigrationsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryStrapiMigrationsVarianceFields = () =>
  new StrapiMigrationsVarianceFieldsQueryBuilder();

export class SubscriptionRootQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.SubscriptionRoot> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.SubscriptionRoot, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const querySubscriptionRoot = () => new SubscriptionRootQueryBuilder();

export class TableMaintenanceLogQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableMaintenanceLog> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TableMaintenanceLog, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableMaintenanceLog = () =>
  new TableMaintenanceLogQueryBuilder();

export class TableMaintenanceLogAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableMaintenanceLogAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableMaintenanceLogAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableMaintenanceLogAggregate = () =>
  new TableMaintenanceLogAggregateQueryBuilder();

export class TableMaintenanceLogAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableMaintenanceLogAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableMaintenanceLogAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableMaintenanceLogAggregateFields = () =>
  new TableMaintenanceLogAggregateFieldsQueryBuilder();

export class TableMaintenanceLogAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableMaintenanceLogAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableMaintenanceLogAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableMaintenanceLogAvgFields = () =>
  new TableMaintenanceLogAvgFieldsQueryBuilder();

export class TableMaintenanceLogMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableMaintenanceLogMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableMaintenanceLogMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableMaintenanceLogMaxFields = () =>
  new TableMaintenanceLogMaxFieldsQueryBuilder();

export class TableMaintenanceLogMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableMaintenanceLogMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableMaintenanceLogMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableMaintenanceLogMinFields = () =>
  new TableMaintenanceLogMinFieldsQueryBuilder();

export class TableMaintenanceLogMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableMaintenanceLogMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableMaintenanceLogMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableMaintenanceLogMutationResponse = () =>
  new TableMaintenanceLogMutationResponseQueryBuilder();

export class TableMaintenanceLogStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableMaintenanceLogStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableMaintenanceLogStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableMaintenanceLogStddevFields = () =>
  new TableMaintenanceLogStddevFieldsQueryBuilder();

export class TableMaintenanceLogStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableMaintenanceLogStddevPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableMaintenanceLogStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableMaintenanceLogStddevPopFields = () =>
  new TableMaintenanceLogStddevPopFieldsQueryBuilder();

export class TableMaintenanceLogStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableMaintenanceLogStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableMaintenanceLogStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableMaintenanceLogStddevSampFields = () =>
  new TableMaintenanceLogStddevSampFieldsQueryBuilder();

export class TableMaintenanceLogSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableMaintenanceLogSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableMaintenanceLogSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableMaintenanceLogSumFields = () =>
  new TableMaintenanceLogSumFieldsQueryBuilder();

export class TableMaintenanceLogVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableMaintenanceLogVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableMaintenanceLogVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableMaintenanceLogVarPopFields = () =>
  new TableMaintenanceLogVarPopFieldsQueryBuilder();

export class TableMaintenanceLogVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableMaintenanceLogVarSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableMaintenanceLogVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableMaintenanceLogVarSampFields = () =>
  new TableMaintenanceLogVarSampFieldsQueryBuilder();

export class TableMaintenanceLogVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableMaintenanceLogVarianceFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableMaintenanceLogVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableMaintenanceLogVarianceFields = () =>
  new TableMaintenanceLogVarianceFieldsQueryBuilder();

export class TableQueryPerformanceQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableQueryPerformance> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TableQueryPerformance, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableQueryPerformance = () =>
  new TableQueryPerformanceQueryBuilder();

export class TableQueryPerformanceAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableQueryPerformanceAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableQueryPerformanceAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableQueryPerformanceAggregate = () =>
  new TableQueryPerformanceAggregateQueryBuilder();

export class TableQueryPerformanceAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableQueryPerformanceAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableQueryPerformanceAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableQueryPerformanceAggregateFields = () =>
  new TableQueryPerformanceAggregateFieldsQueryBuilder();

export class TableQueryPerformanceAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableQueryPerformanceAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableQueryPerformanceAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableQueryPerformanceAvgFields = () =>
  new TableQueryPerformanceAvgFieldsQueryBuilder();

export class TableQueryPerformanceMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableQueryPerformanceMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableQueryPerformanceMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableQueryPerformanceMaxFields = () =>
  new TableQueryPerformanceMaxFieldsQueryBuilder();

export class TableQueryPerformanceMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableQueryPerformanceMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableQueryPerformanceMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableQueryPerformanceMinFields = () =>
  new TableQueryPerformanceMinFieldsQueryBuilder();

export class TableQueryPerformanceMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableQueryPerformanceMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableQueryPerformanceMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableQueryPerformanceMutationResponse = () =>
  new TableQueryPerformanceMutationResponseQueryBuilder();

export class TableQueryPerformanceStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableQueryPerformanceStddevFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableQueryPerformanceStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableQueryPerformanceStddevFields = () =>
  new TableQueryPerformanceStddevFieldsQueryBuilder();

export class TableQueryPerformanceStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableQueryPerformanceStddevPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableQueryPerformanceStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableQueryPerformanceStddevPopFields = () =>
  new TableQueryPerformanceStddevPopFieldsQueryBuilder();

export class TableQueryPerformanceStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableQueryPerformanceStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableQueryPerformanceStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableQueryPerformanceStddevSampFields = () =>
  new TableQueryPerformanceStddevSampFieldsQueryBuilder();

export class TableQueryPerformanceSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableQueryPerformanceSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableQueryPerformanceSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableQueryPerformanceSumFields = () =>
  new TableQueryPerformanceSumFieldsQueryBuilder();

export class TableQueryPerformanceVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableQueryPerformanceVarPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableQueryPerformanceVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableQueryPerformanceVarPopFields = () =>
  new TableQueryPerformanceVarPopFieldsQueryBuilder();

export class TableQueryPerformanceVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableQueryPerformanceVarSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableQueryPerformanceVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableQueryPerformanceVarSampFields = () =>
  new TableQueryPerformanceVarSampFieldsQueryBuilder();

export class TableQueryPerformanceVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableQueryPerformanceVarianceFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableQueryPerformanceVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableQueryPerformanceVarianceFields = () =>
  new TableQueryPerformanceVarianceFieldsQueryBuilder();

export class TableSequenceUsageQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableSequenceUsage> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TableSequenceUsage, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableSequenceUsage = () =>
  new TableSequenceUsageQueryBuilder();

export class TableSequenceUsageAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableSequenceUsageAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableSequenceUsageAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableSequenceUsageAggregate = () =>
  new TableSequenceUsageAggregateQueryBuilder();

export class TableSequenceUsageAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableSequenceUsageAggregateFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableSequenceUsageAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableSequenceUsageAggregateFields = () =>
  new TableSequenceUsageAggregateFieldsQueryBuilder();

export class TableSequenceUsageAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableSequenceUsageAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableSequenceUsageAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableSequenceUsageAvgFields = () =>
  new TableSequenceUsageAvgFieldsQueryBuilder();

export class TableSequenceUsageMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableSequenceUsageMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableSequenceUsageMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableSequenceUsageMaxFields = () =>
  new TableSequenceUsageMaxFieldsQueryBuilder();

export class TableSequenceUsageMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableSequenceUsageMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableSequenceUsageMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableSequenceUsageMinFields = () =>
  new TableSequenceUsageMinFieldsQueryBuilder();

export class TableSequenceUsageMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableSequenceUsageMutationResponse> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableSequenceUsageMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableSequenceUsageMutationResponse = () =>
  new TableSequenceUsageMutationResponseQueryBuilder();

export class TableSequenceUsageStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableSequenceUsageStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableSequenceUsageStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableSequenceUsageStddevFields = () =>
  new TableSequenceUsageStddevFieldsQueryBuilder();

export class TableSequenceUsageStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableSequenceUsageStddevPopFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableSequenceUsageStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableSequenceUsageStddevPopFields = () =>
  new TableSequenceUsageStddevPopFieldsQueryBuilder();

export class TableSequenceUsageStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableSequenceUsageStddevSampFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableSequenceUsageStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableSequenceUsageStddevSampFields = () =>
  new TableSequenceUsageStddevSampFieldsQueryBuilder();

export class TableSequenceUsageSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableSequenceUsageSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableSequenceUsageSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableSequenceUsageSumFields = () =>
  new TableSequenceUsageSumFieldsQueryBuilder();

export class TableSequenceUsageVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableSequenceUsageVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableSequenceUsageVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableSequenceUsageVarPopFields = () =>
  new TableSequenceUsageVarPopFieldsQueryBuilder();

export class TableSequenceUsageVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableSequenceUsageVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableSequenceUsageVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableSequenceUsageVarSampFields = () =>
  new TableSequenceUsageVarSampFieldsQueryBuilder();

export class TableSequenceUsageVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableSequenceUsageVarianceFields> =
    {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableSequenceUsageVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableSequenceUsageVarianceFields = () =>
  new TableSequenceUsageVarianceFieldsQueryBuilder();

export class TableStatisticsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableStatistics> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TableStatistics, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableStatistics = () => new TableStatisticsQueryBuilder();

export class TableStatisticsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableStatisticsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableStatisticsAggregate,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableStatisticsAggregate = () =>
  new TableStatisticsAggregateQueryBuilder();

export class TableStatisticsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableStatisticsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableStatisticsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableStatisticsAggregateFields = () =>
  new TableStatisticsAggregateFieldsQueryBuilder();

export class TableStatisticsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableStatisticsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableStatisticsAvgFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableStatisticsAvgFields = () =>
  new TableStatisticsAvgFieldsQueryBuilder();

export class TableStatisticsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableStatisticsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableStatisticsMaxFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableStatisticsMaxFields = () =>
  new TableStatisticsMaxFieldsQueryBuilder();

export class TableStatisticsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableStatisticsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableStatisticsMinFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableStatisticsMinFields = () =>
  new TableStatisticsMinFieldsQueryBuilder();

export class TableStatisticsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableStatisticsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableStatisticsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableStatisticsMutationResponse = () =>
  new TableStatisticsMutationResponseQueryBuilder();

export class TableStatisticsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableStatisticsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableStatisticsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableStatisticsStddevFields = () =>
  new TableStatisticsStddevFieldsQueryBuilder();

export class TableStatisticsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableStatisticsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableStatisticsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableStatisticsStddevPopFields = () =>
  new TableStatisticsStddevPopFieldsQueryBuilder();

export class TableStatisticsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableStatisticsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableStatisticsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableStatisticsStddevSampFields = () =>
  new TableStatisticsStddevSampFieldsQueryBuilder();

export class TableStatisticsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableStatisticsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableStatisticsSumFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableStatisticsSumFields = () =>
  new TableStatisticsSumFieldsQueryBuilder();

export class TableStatisticsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableStatisticsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableStatisticsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableStatisticsVarPopFields = () =>
  new TableStatisticsVarPopFieldsQueryBuilder();

export class TableStatisticsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableStatisticsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableStatisticsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableStatisticsVarSampFields = () =>
  new TableStatisticsVarSampFieldsQueryBuilder();

export class TableStatisticsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TableStatisticsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.TableStatisticsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTableStatisticsVarianceFields = () =>
  new TableStatisticsVarianceFieldsQueryBuilder();

export class TagsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Tags> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Tags, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTags = () => new TagsQueryBuilder();

export class TagsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TagsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TagsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTagsAggregate = () => new TagsAggregateQueryBuilder();

export class TagsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TagsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TagsAggregateFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTagsAggregateFields = () =>
  new TagsAggregateFieldsQueryBuilder();

export class TagsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TagsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TagsAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTagsAvgFields = () => new TagsAvgFieldsQueryBuilder();

export class TagsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TagsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TagsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTagsMaxFields = () => new TagsMaxFieldsQueryBuilder();

export class TagsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TagsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TagsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTagsMinFields = () => new TagsMinFieldsQueryBuilder();

export class TagsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TagsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TagsMutationResponse, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTagsMutationResponse = () =>
  new TagsMutationResponseQueryBuilder();

export class TagsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TagsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TagsStddevFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTagsStddevFields = () => new TagsStddevFieldsQueryBuilder();

export class TagsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TagsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TagsStddevPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTagsStddevPopFields = () =>
  new TagsStddevPopFieldsQueryBuilder();

export class TagsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TagsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TagsStddevSampFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTagsStddevSampFields = () =>
  new TagsStddevSampFieldsQueryBuilder();

export class TagsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TagsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TagsSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTagsSumFields = () => new TagsSumFieldsQueryBuilder();

export class TagsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TagsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TagsVarPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTagsVarPopFields = () => new TagsVarPopFieldsQueryBuilder();

export class TagsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TagsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TagsVarSampFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTagsVarSampFields = () => new TagsVarSampFieldsQueryBuilder();

export class TagsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.TagsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.TagsVarianceFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryTagsVarianceFields = () =>
  new TagsVarianceFieldsQueryBuilder();

export class UserMetricsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserMetrics> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.UserMetrics, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserMetrics = () => new UserMetricsQueryBuilder();

export class UserMetricsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserMetricsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.UserMetricsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserMetricsAggregate = () =>
  new UserMetricsAggregateQueryBuilder();

export class UserMetricsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserMetricsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserMetricsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserMetricsAggregateFields = () =>
  new UserMetricsAggregateFieldsQueryBuilder();

export class UserMetricsAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserMetricsAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.UserMetricsAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserMetricsAvgFields = () =>
  new UserMetricsAvgFieldsQueryBuilder();

export class UserMetricsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserMetricsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.UserMetricsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserMetricsMaxFields = () =>
  new UserMetricsMaxFieldsQueryBuilder();

export class UserMetricsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserMetricsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.UserMetricsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserMetricsMinFields = () =>
  new UserMetricsMinFieldsQueryBuilder();

export class UserMetricsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserMetricsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserMetricsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserMetricsMutationResponse = () =>
  new UserMetricsMutationResponseQueryBuilder();

export class UserMetricsStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserMetricsStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserMetricsStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserMetricsStddevFields = () =>
  new UserMetricsStddevFieldsQueryBuilder();

export class UserMetricsStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserMetricsStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserMetricsStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserMetricsStddevPopFields = () =>
  new UserMetricsStddevPopFieldsQueryBuilder();

export class UserMetricsStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserMetricsStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserMetricsStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserMetricsStddevSampFields = () =>
  new UserMetricsStddevSampFieldsQueryBuilder();

export class UserMetricsSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserMetricsSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.UserMetricsSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserMetricsSumFields = () =>
  new UserMetricsSumFieldsQueryBuilder();

export class UserMetricsVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserMetricsVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserMetricsVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserMetricsVarPopFields = () =>
  new UserMetricsVarPopFieldsQueryBuilder();

export class UserMetricsVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserMetricsVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserMetricsVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserMetricsVarSampFields = () =>
  new UserMetricsVarSampFieldsQueryBuilder();

export class UserMetricsVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserMetricsVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserMetricsVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserMetricsVarianceFields = () =>
  new UserMetricsVarianceFieldsQueryBuilder();

export class UserProfilesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserProfiles> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.UserProfiles, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserProfiles = () => new UserProfilesQueryBuilder();

export class UserProfilesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserProfilesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.UserProfilesAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserProfilesAggregate = () =>
  new UserProfilesAggregateQueryBuilder();

export class UserProfilesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserProfilesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserProfilesAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserProfilesAggregateFields = () =>
  new UserProfilesAggregateFieldsQueryBuilder();

export class UserProfilesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserProfilesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.UserProfilesAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserProfilesAvgFields = () =>
  new UserProfilesAvgFieldsQueryBuilder();

export class UserProfilesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserProfilesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.UserProfilesMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserProfilesMaxFields = () =>
  new UserProfilesMaxFieldsQueryBuilder();

export class UserProfilesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserProfilesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.UserProfilesMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserProfilesMinFields = () =>
  new UserProfilesMinFieldsQueryBuilder();

export class UserProfilesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserProfilesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserProfilesMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserProfilesMutationResponse = () =>
  new UserProfilesMutationResponseQueryBuilder();

export class UserProfilesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserProfilesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserProfilesStddevFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserProfilesStddevFields = () =>
  new UserProfilesStddevFieldsQueryBuilder();

export class UserProfilesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserProfilesStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserProfilesStddevPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserProfilesStddevPopFields = () =>
  new UserProfilesStddevPopFieldsQueryBuilder();

export class UserProfilesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserProfilesStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserProfilesStddevSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserProfilesStddevSampFields = () =>
  new UserProfilesStddevSampFieldsQueryBuilder();

export class UserProfilesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserProfilesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.UserProfilesSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserProfilesSumFields = () =>
  new UserProfilesSumFieldsQueryBuilder();

export class UserProfilesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserProfilesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserProfilesVarPopFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserProfilesVarPopFields = () =>
  new UserProfilesVarPopFieldsQueryBuilder();

export class UserProfilesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserProfilesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserProfilesVarSampFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserProfilesVarSampFields = () =>
  new UserProfilesVarSampFieldsQueryBuilder();

export class UserProfilesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.UserProfilesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.UserProfilesVarianceFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryUserProfilesVarianceFields = () =>
  new UserProfilesVarianceFieldsQueryBuilder();

export class VotesQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Votes> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Votes, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryVotes = () => new VotesQueryBuilder();

export class VotesAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.VotesAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.VotesAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryVotesAggregate = () => new VotesAggregateQueryBuilder();

export class VotesAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.VotesAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.VotesAggregateFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryVotesAggregateFields = () =>
  new VotesAggregateFieldsQueryBuilder();

export class VotesAvgFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.VotesAvgFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.VotesAvgFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryVotesAvgFields = () => new VotesAvgFieldsQueryBuilder();

export class VotesMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.VotesMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.VotesMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryVotesMaxFields = () => new VotesMaxFieldsQueryBuilder();

export class VotesMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.VotesMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.VotesMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryVotesMinFields = () => new VotesMinFieldsQueryBuilder();

export class VotesMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.VotesMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.VotesMutationResponse, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryVotesMutationResponse = () =>
  new VotesMutationResponseQueryBuilder();

export class VotesStddevFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.VotesStddevFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.VotesStddevFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryVotesStddevFields = () => new VotesStddevFieldsQueryBuilder();

export class VotesStddevPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.VotesStddevPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.VotesStddevPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryVotesStddevPopFields = () =>
  new VotesStddevPopFieldsQueryBuilder();

export class VotesStddevSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.VotesStddevSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.VotesStddevSampFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryVotesStddevSampFields = () =>
  new VotesStddevSampFieldsQueryBuilder();

export class VotesSumFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.VotesSumFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.VotesSumFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryVotesSumFields = () => new VotesSumFieldsQueryBuilder();

export class VotesVarPopFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.VotesVarPopFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.VotesVarPopFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryVotesVarPopFields = () => new VotesVarPopFieldsQueryBuilder();

export class VotesVarSampFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.VotesVarSampFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.VotesVarSampFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryVotesVarSampFields = () =>
  new VotesVarSampFieldsQueryBuilder();

export class VotesVarianceFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.VotesVarianceFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.VotesVarianceFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryVotesVarianceFields = () =>
  new VotesVarianceFieldsQueryBuilder();

export class WorkflowsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.Workflows> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.Workflows, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryWorkflows = () => new WorkflowsQueryBuilder();

export class WorkflowsAggregateQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.WorkflowsAggregate> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.WorkflowsAggregate, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryWorkflowsAggregate = () =>
  new WorkflowsAggregateQueryBuilder();

export class WorkflowsAggregateFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.WorkflowsAggregateFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.WorkflowsAggregateFields,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryWorkflowsAggregateFields = () =>
  new WorkflowsAggregateFieldsQueryBuilder();

export class WorkflowsMaxFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.WorkflowsMaxFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.WorkflowsMaxFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryWorkflowsMaxFields = () =>
  new WorkflowsMaxFieldsQueryBuilder();

export class WorkflowsMinFieldsQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.WorkflowsMinFields> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(field: keyof Types.WorkflowsMinFields, direction: "asc" | "desc") {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryWorkflowsMinFields = () =>
  new WorkflowsMinFieldsQueryBuilder();

export class WorkflowsMutationResponseQueryBuilder {
  private whereClause: WhereInput = {};
  private orderByClause?: OrderByInput;
  private limitValue?: number;
  private offsetValue?: number;
  private selection: FieldSelection<Types.WorkflowsMutationResponse> = {};

  where(input: WhereInput) {
    this.whereClause = { ...this.whereClause, ...input };
    return this;
  }

  orderBy(
    field: keyof Types.WorkflowsMutationResponse,
    direction: "asc" | "desc",
  ) {
    this.orderByClause = { [field]: direction };
    return this;
  }

  limit(value: number) {
    this.limitValue = value;
    return this;
  }

  offset(value: number) {
    this.offsetValue = value;
    return this;
  }

  select<T extends FieldSelection<T>>(selection: T) {
    this.selection = selection;
    return this;
  }

  build() {
    return {
      where: this.whereClause,
      orderBy: this.orderByClause,
      limit: this.limitValue,
      offset: this.offsetValue,
      select: this.selection,
    };
  }
}

export const queryWorkflowsMutationResponse = () =>
  new WorkflowsMutationResponseQueryBuilder();