export type Maybe<T> = T | null;

export interface BusinessUnitInput {
  slug: string;

  countryCode: string;
}

export interface FilterInput {
  slug: string;

  type: string;
}

export interface DivisionInput {
  slug: string;

  businessUnitInput: BusinessUnitInput;
}

export type Json = any;

export type Date = any;

// ====================================================
// Scalars
// ====================================================

// ====================================================
// Types
// ====================================================

export interface Query {
  country?: Maybe<Country>;

  businessUnits?: Maybe<(Maybe<BusinessUnit>)[]>;

  businessUnit?: Maybe<BusinessUnit>;

  companies?: Maybe<(Maybe<Company>)[]>;

  company?: Maybe<Company>;

  division?: Maybe<Division>;

  divisions?: Maybe<(Maybe<Division>)[]>;

  education?: Maybe<Education>;

  educations?: Maybe<(Maybe<Education>)[]>;

  categories?: Maybe<(Maybe<Category>)[]>;

  entities?: Maybe<(Maybe<Entity>)[]>;

  entity?: Maybe<Entity>;

  entityFilters?: Maybe<(Maybe<EntityFilter>)[]>;

  entityFilter?: Maybe<EntityFilter>;

  filters?: Maybe<(Maybe<Filter>)[]>;

  filtersFromInputs?: Maybe<(Maybe<Filter>)[]>;

  landing?: Maybe<Landing>;

  landingWithFallback?: Maybe<LandingWithFallback>;

  product?: Maybe<Product>;

  productByCode?: Maybe<Product>;

  products?: Maybe<(Maybe<Product>)[]>;

  productsFromSearch?: Maybe<(Maybe<Product>)[]>;

  productAttributes?: Maybe<(Maybe<ProductAttribute>)[]>;
}

export interface Country {
  id: number;

  name: string;

  code: string;
}

export interface BusinessUnit {
  id: number;

  name: string;

  code: string;

  slug: string;

  category: string;

  country?: Maybe<Country>;

  logo?: Maybe<string>;

  icon?: Maybe<string>;

  config?: Maybe<Json>;

  filters?: Maybe<(Maybe<Filter>)[]>;

  products?: Maybe<ProductsConnection>;
}

export interface Filter {
  id: number;

  code: string;

  operator: string;

  label: string;

  slug: string;

  sortable: boolean;

  count?: Maybe<number>;

  value: Json;

  order: number;

  preFilter: boolean;

  description?: Maybe<string>;

  entityFilter: EntityFilter;

  businessUnit: BusinessUnit;
}

export interface EntityFilter {
  id: number;

  code: string;

  featured: boolean;

  level: number;

  order: number;

  entity: Entity;

  description?: Maybe<string>;

  filters?: Maybe<(Maybe<Filter>)[]>;

  fieldAccessor?: Maybe<string>;

  inclusive?: Maybe<boolean>;

  withEntity?: Maybe<boolean>;

  withPreposition?: Maybe<boolean>;
}

export interface Entity {
  id: number;

  code: string;

  dataType: string;

  config?: Maybe<Json>;

  icon?: Maybe<string>;

  label: string;

  group?: Maybe<Json>;

  slug: string;

  extraDescription?: Maybe<string>;
}

export interface ProductsConnection {
  totalCount?: Maybe<number>;

  edges?: Maybe<(Maybe<ProductsEdge>)[]>;
}

export interface ProductsEdge {
  node?: Maybe<Product>;
}

export interface Product {
  id: string;

  code: string;

  name: string;

  slug: string;

  redirect?: Maybe<string>;

  logo?: Maybe<string>;

  relevance: number;

  divisionId: string;

  division: Division;

  active: boolean;

  enabled: boolean;

  partner: boolean;

  conversion?: Maybe<number>;

  mainAttribute?: Maybe<ProductAttribute>;

  landingMainAttribute?: Maybe<ProductAttribute>;

  productAttributes?: Maybe<(Maybe<ProductAttribute>)[]>;

  featuredAttributes?: Maybe<(Maybe<ProductAttribute>)[]>;
}

export interface Division {
  id: number;

  name: string;

  code: string;

  slug: string;

  logo?: Maybe<string>;

  email?: Maybe<string>;

  website?: Maybe<string>;

  description?: Maybe<string>;

  phone?: Maybe<Json>;

  partner: boolean;

  landingDescriptionTitle?: Maybe<string>;

  landingDescriptionContentHtml?: Maybe<string>;

  company: Company;

  companyId: string;

  businessUnit: BusinessUnit;

  products?: Maybe<ProductsConnection>;
}

export interface Company {
  id: number;

  name: string;

  code: string;

  slug: string;

  email?: Maybe<string>;

  website?: Maybe<string>;

  description?: Maybe<string>;

  phone?: Maybe<Json>;

  divisions?: Maybe<(Maybe<Division>)[]>;
}

export interface ProductAttribute {
  id: number;

  extraDescription?: Maybe<string>;

  level?: Maybe<number>;

  featured?: Maybe<boolean>;

  enabled?: Maybe<boolean>;

  landingGroup?: Maybe<boolean>;

  strikedthrough?: Maybe<boolean>;

  highlight?: Maybe<boolean>;

  descriptor?: Maybe<boolean>;

  value: Json;

  product: Product;

  entity: Entity;

  isAccurate: boolean;

  parentCode?: Maybe<string>;

  code?: Maybe<string>;
}

export interface Education {
  id: number;

  question: string;

  introduction: string;

  answer: string;

  answerHtml: string;

  shortAnswer: string;

  slug: string;

  author?: Maybe<string>;

  order: number;

  businessUnit: BusinessUnit;

  withImage: boolean;

  inLanding: boolean;

  createdAt: string;

  updatedAt: string;

  config: Json;
}

export interface Category {
  id: number;

  url: string;

  code: string;

  icon: string;

  order: number;

  name: string;

  withRedirect: boolean;

  businessUnit: BusinessUnit;
}

export interface Landing {
  id: number;

  metaTitle?: Maybe<string>;

  metaDescription?: Maybe<string>;

  title?: Maybe<string>;

  description?: Maybe<string>;

  businessUnit?: Maybe<BusinessUnit>;

  noIndex?: Maybe<boolean>;
}

export interface LandingWithFallback {
  id: number;

  metaTitle?: Maybe<string>;

  metaDescription?: Maybe<string>;

  title?: Maybe<string>;

  description?: Maybe<string>;

  businessUnit?: Maybe<BusinessUnit>;

  noIndex?: Maybe<boolean>;

  path?: Maybe<string>;
}

// ====================================================
// Arguments
// ====================================================

export interface CountryQueryArgs {
  id?: Maybe<number>;
}
export interface BusinessUnitsQueryArgs {
  countryId?: Maybe<number>;
}
export interface BusinessUnitQueryArgs {
  businessUnitInput?: Maybe<BusinessUnitInput>;
}
export interface DivisionQueryArgs {
  id?: Maybe<number>;

  divisionInput?: Maybe<DivisionInput>;
}
export interface DivisionsQueryArgs {
  businessUnitId?: Maybe<number>;

  companyId?: Maybe<number>;

  countryCode?: Maybe<string>;
}
export interface EducationQueryArgs {
  businessUnitInput?: Maybe<BusinessUnitInput>;

  tipSlug?: Maybe<string>;
}
export interface EducationsQueryArgs {
  businessUnitInput?: Maybe<BusinessUnitInput>;

  path?: Maybe<string>;

  orderBy?: Maybe<string>;

  desc?: Maybe<boolean>;
}
export interface CategoriesQueryArgs {
  businessUnitInput?: Maybe<BusinessUnitInput>;
}
export interface EntitiesQueryArgs {
  businessUnitInput?: Maybe<BusinessUnitInput>;
}
export interface EntityFiltersQueryArgs {
  businessUnitInput?: Maybe<BusinessUnitInput>;

  orderBy?: Maybe<string>;

  desc?: Maybe<boolean>;

  filterSearchSlugs?: Maybe<(Maybe<string>)[]>;
}
export interface FiltersQueryArgs {
  businessUnitInput?: Maybe<BusinessUnitInput>;

  businessUnitCode?: Maybe<string>;

  filtersInput?: Maybe<(Maybe<FilterInput>)[]>;
}
export interface FiltersFromInputsQueryArgs {
  businessUnitInput: BusinessUnitInput;

  filtersInput: (Maybe<FilterInput>)[];
}
export interface LandingQueryArgs {
  businessUnitInput: BusinessUnitInput;

  path?: Maybe<string>;
}
export interface LandingWithFallbackQueryArgs {
  businessUnitInput: BusinessUnitInput;

  path?: Maybe<string>;
}
export interface ProductQueryArgs {
  slug?: Maybe<string>;

  businessUnitInput?: Maybe<BusinessUnitInput>;

  divisionSlug?: Maybe<string>;

  code?: Maybe<string>;
}
export interface ProductByCodeQueryArgs {
  code: string;
}
export interface ProductsQueryArgs {
  divisionId?: Maybe<number>;

  businessUnitInput?: Maybe<BusinessUnitInput>;

  filtersInput?: Maybe<(Maybe<FilterInput>)[]>;

  notFromDivision?: Maybe<DivisionInput>;

  businessUnitCode?: Maybe<string>;

  limit?: Maybe<number>;

  orderBy?: Maybe<string>;
}
export interface ProductsFromSearchQueryArgs {
  businessUnitInput: BusinessUnitInput;

  filterSearchSlugs?: Maybe<(Maybe<string>)[]>;

  limit?: Maybe<number>;

  orderBy?: Maybe<string>;
}
export interface ProductsBusinessUnitArgs {
  filtersInput?: Maybe<(Maybe<FilterInput>)[]>;

  page?: Maybe<number>;

  limit?: Maybe<number>;

  orderBy?: Maybe<string>;

  desc?: Maybe<boolean>;
}
export interface FiltersEntityFilterArgs {
  businessUnitInput?: Maybe<BusinessUnitInput>;

  filterSearchSlugs?: Maybe<(Maybe<string>)[]>;

  entityFilterId?: Maybe<number>;
}
export interface ProductsDivisionArgs {
  limit?: Maybe<number>;

  page?: Maybe<number>;

  orderBy?: Maybe<string>;
}
export interface DivisionsCompanyArgs {
  countryCode?: Maybe<string>;
}