import type * as gql_doc from "@graphql-typed-document-node/core";
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: string;
  String: string;
  Boolean: boolean;
  Int: number;
  Float: number;
  _Any: any;
};

export type Continent = {
  __typename?: "Continent";
  code: Scalars["ID"];
  countries: Array<Country>;
  name: Scalars["String"];
};

export type ContinentFilterInput = {
  code?: InputMaybe<StringQueryOperatorInput>;
};

export type Country = {
  __typename?: "Country";
  capital?: Maybe<Scalars["String"]>;
  code: Scalars["ID"];
  continent: Continent;
  currency?: Maybe<Scalars["String"]>;
  emoji: Scalars["String"];
  emojiU: Scalars["String"];
  languages: Array<Language>;
  name: Scalars["String"];
  native: Scalars["String"];
  phone: Scalars["String"];
  states: Array<State>;
};

export type CountryFilterInput = {
  code?: InputMaybe<StringQueryOperatorInput>;
  continent?: InputMaybe<StringQueryOperatorInput>;
  currency?: InputMaybe<StringQueryOperatorInput>;
};

export type Language = {
  __typename?: "Language";
  code: Scalars["ID"];
  name?: Maybe<Scalars["String"]>;
  native?: Maybe<Scalars["String"]>;
  rtl: Scalars["Boolean"];
};

export type LanguageFilterInput = {
  code?: InputMaybe<StringQueryOperatorInput>;
};

export type Query = {
  __typename?: "Query";
  _entities: Array<Maybe<_Entity>>;
  _service: _Service;
  continent?: Maybe<Continent>;
  continents: Array<Continent>;
  countries: Array<Country>;
  country?: Maybe<Country>;
  language?: Maybe<Language>;
  languages: Array<Language>;
};

export type Query_EntitiesArgs = {
  representations: Array<Scalars["_Any"]>;
};

export type QueryContinentArgs = {
  code: Scalars["ID"];
};

export type QueryContinentsArgs = {
  filter?: InputMaybe<ContinentFilterInput>;
};

export type QueryCountriesArgs = {
  filter?: InputMaybe<CountryFilterInput>;
};

export type QueryCountryArgs = {
  code: Scalars["ID"];
};

export type QueryLanguageArgs = {
  code: Scalars["ID"];
};

export type QueryLanguagesArgs = {
  filter?: InputMaybe<LanguageFilterInput>;
};

export type State = {
  __typename?: "State";
  code?: Maybe<Scalars["String"]>;
  country: Country;
  name: Scalars["String"];
};

export type StringQueryOperatorInput = {
  eq?: InputMaybe<Scalars["String"]>;
  glob?: InputMaybe<Scalars["String"]>;
  in?: InputMaybe<Array<InputMaybe<Scalars["String"]>>>;
  ne?: InputMaybe<Scalars["String"]>;
  nin?: InputMaybe<Array<InputMaybe<Scalars["String"]>>>;
  regex?: InputMaybe<Scalars["String"]>;
};

export type _Entity = Continent | Country | Language;

export type _Service = {
  __typename?: "_Service";
  /** The sdl representing the federated service capabilities. Includes federation directives, removes federation types, and includes rest of full schema after schema directives have been applied */
  sdl?: Maybe<Scalars["String"]>;
};

export type CountryQueryQueryVariables = Exact<{
  code: Scalars["ID"];
}>;

export type CountryQueryQuery = {
  __typename?: "Query";
  country?: { __typename?: "Country"; name: string } | null;
};

export type CountriesQueryQueryVariables = Exact<{ [key: string]: never }>;

export type CountriesQueryQuery = {
  __typename?: "Query";
  countries: Array<{ __typename?: "Country"; name: string; code: string }>;
};

export const CountryQueryDocument = {
  kind: "Document",
  definitions: [
    {
      kind: "OperationDefinition",
      operation: "query",
      name: { kind: "Name", value: "CountryQuery" },
      variableDefinitions: [
        {
          kind: "VariableDefinition",
          variable: { kind: "Variable", name: { kind: "Name", value: "code" } },
          type: {
            kind: "NonNullType",
            type: { kind: "NamedType", name: { kind: "Name", value: "ID" } },
          },
        },
      ],
      selectionSet: {
        kind: "SelectionSet",
        selections: [
          {
            kind: "Field",
            name: { kind: "Name", value: "country" },
            arguments: [
              {
                kind: "Argument",
                name: { kind: "Name", value: "code" },
                value: { kind: "Variable", name: { kind: "Name", value: "code" } },
              },
            ],
            selectionSet: {
              kind: "SelectionSet",
              selections: [{ kind: "Field", name: { kind: "Name", value: "name" } }],
            },
          },
        ],
      },
    },
  ],
} as unknown as gql_doc.TypedDocumentNode<CountryQueryQuery, CountryQueryQueryVariables>;
export const CountriesQueryDocument = {
  kind: "Document",
  definitions: [
    {
      kind: "OperationDefinition",
      operation: "query",
      name: { kind: "Name", value: "CountriesQuery" },
      selectionSet: {
        kind: "SelectionSet",
        selections: [
          {
            kind: "Field",
            name: { kind: "Name", value: "countries" },
            selectionSet: {
              kind: "SelectionSet",
              selections: [
                { kind: "Field", name: { kind: "Name", value: "name" } },
                { kind: "Field", name: { kind: "Name", value: "code" } },
              ],
            },
          },
        ],
      },
    },
  ],
} as unknown as gql_doc.TypedDocumentNode<CountriesQueryQuery, CountriesQueryQueryVariables>;
