import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
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]>;
};
export type MakeEmpty<T extends {
    [key: string]: unknown;
}, K extends keyof T> = {
    [_ in K]?: never;
};
export type Incremental<T> = T | {
    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
};
export type RequireFields<T, K extends keyof T> = Omit<T, K> & {
    [P in K]-?: NonNullable<T[P]>;
};
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
    ID: {
        input: string;
        output: string;
    };
    String: {
        input: string;
        output: string;
    };
    Boolean: {
        input: boolean;
        output: boolean;
    };
    Int: {
        input: number;
        output: number;
    };
    Float: {
        input: number;
        output: number;
    };
    AnyObject: {
        input: any;
        output: any;
    };
    Date: {
        input: any;
        output: any;
    };
    DateTime: {
        input: any;
        output: any;
    };
    JSON: {
        input: any;
        output: any;
    };
    JSONObject: {
        input: any;
        output: any;
    };
    Observable: {
        input: any;
        output: any;
    };
    Time: {
        input: any;
        output: any;
    };
    URI: {
        input: any;
        output: any;
    };
    URIInput: {
        input: any;
        output: any;
    };
};
export type IAdminIdeSettings = {
    __typename?: 'AdminIdeSettings';
    dummy?: Maybe<Scalars['Int']['output']>;
};
export declare enum ICacheControlScope {
    Private = "PRIVATE",
    Public = "PUBLIC"
}
export type ICities = {
    __typename?: 'Cities';
    data?: Maybe<Array<Maybe<ICity>>>;
    totalCount: Scalars['Int']['output'];
};
export type ICitiesInput = {
    cityOptions?: InputMaybe<ICitiesOptions>;
    countryOptions?: InputMaybe<ICitiesOptions>;
    stateOptions?: InputMaybe<ICitiesOptions>;
};
export type ICitiesOptions = {
    criteria?: InputMaybe<Scalars['AnyObject']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    skip?: InputMaybe<Scalars['Int']['input']>;
    sort?: InputMaybe<ISort>;
};
/** Pub N Go Property Address City */
export type ICity = IICity & {
    __typename?: 'City';
    createdAt: Scalars['DateTime']['output'];
    id: Scalars['ID']['output'];
    location?: Maybe<IGeoLocation>;
    name: Scalars['String']['output'];
    state: IState;
    updatedAt: Scalars['DateTime']['output'];
};
/** Address City Create Input */
export type ICityInput = {
    /** Name of the state to display */
    name: Scalars['String']['input'];
    /** ID of State to associate */
    state: ITerritorialStateInput;
};
/** Address City Update Input */
export type ICityUpdateInput = {
    name?: InputMaybe<Scalars['String']['input']>;
    state: ITerritorialStateUpdateInput;
};
export type ICountries = {
    __typename?: 'Countries';
    data?: Maybe<Array<Maybe<ICountry>>>;
    totalCount: Scalars['Int']['output'];
};
export type ICountry = IICountry & {
    __typename?: 'Country';
    createdAt: Scalars['DateTime']['output'];
    currency?: Maybe<Scalars['String']['output']>;
    currency_symbol?: Maybe<Scalars['String']['output']>;
    emoji?: Maybe<Scalars['String']['output']>;
    id: Scalars['ID']['output'];
    location?: Maybe<IGeoLocation>;
    name: Scalars['String']['output'];
    phone_code: Scalars['String']['output'];
    states?: Maybe<IStates>;
    updatedAt: Scalars['DateTime']['output'];
};
export type ICountryStatesArgs = {
    criteria?: InputMaybe<Scalars['AnyObject']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    skip?: InputMaybe<Scalars['Int']['input']>;
    sort?: InputMaybe<ISort>;
};
export type ICountryInput = {
    name: Scalars['String']['input'];
};
/** Represents a null return value. */
export type IEmptyResponse = {
    __typename?: 'EmptyResponse';
    alwaysNil?: Maybe<Scalars['String']['output']>;
};
export type IFieldError = {
    __typename?: 'FieldError';
    field: Scalars['String']['output'];
    message: Scalars['String']['output'];
};
export type IGeoLocation = {
    __typename?: 'GeoLocation';
    coordinates?: Maybe<Array<Maybe<Scalars['Float']['output']>>>;
    type?: Maybe<Scalars['String']['output']>;
};
/**
 * Input geometry of the location.
 * List the `longitude` first and then `latitude`
 *  - Validate longitude values are between `-180` and `180`
 *  - Validate latitude values are between `-90` and `90`
 */
export type IGeoLocationInput = {
    coordinates?: InputMaybe<Array<InputMaybe<Scalars['Float']['input']>>>;
    type?: InputMaybe<Scalars['String']['input']>;
};
/** Address City Interface */
export type IICity = {
    createdAt: Scalars['DateTime']['output'];
    id: Scalars['ID']['output'];
    location?: Maybe<IGeoLocation>;
    name: Scalars['String']['output'];
    state: IITerritorialState;
    updatedAt: Scalars['DateTime']['output'];
};
export type IICountry = {
    createdAt: Scalars['DateTime']['output'];
    currency?: Maybe<Scalars['String']['output']>;
    currency_symbol?: Maybe<Scalars['String']['output']>;
    emoji?: Maybe<Scalars['String']['output']>;
    id: Scalars['ID']['output'];
    location?: Maybe<IGeoLocation>;
    name: Scalars['String']['output'];
    phone_code: Scalars['String']['output'];
    updatedAt: Scalars['DateTime']['output'];
};
export type IIResourceUtilizationSettings = {
    adminApiNamespace?: Maybe<Scalars['String']['output']>;
    subTopic?: Maybe<Scalars['String']['output']>;
};
/** Territorial State */
export type IITerritorialState = {
    country: IICountry;
    createdAt: Scalars['DateTime']['output'];
    id: Scalars['ID']['output'];
    location?: Maybe<IGeoLocation>;
    name: Scalars['String']['output'];
    updatedAt: Scalars['DateTime']['output'];
};
export declare enum IMailTemplateId {
    Dummy = "dummy"
}
export declare enum IMoleculerCronServiceName {
    Dummy = "dummy"
}
/**  All Moleculer Topic names are extended from this. */
export declare enum IMoleculerServiceName {
    Dummy = "dummy"
}
export type IMutation = {
    __typename?: 'Mutation';
    createCity: ICity;
    createCountry: ICountry;
    createState: IState;
    deleteCity: Scalars['Boolean']['output'];
    deleteCountry: Scalars['Boolean']['output'];
    deleteState: Scalars['Boolean']['output'];
    dummy?: Maybe<Scalars['Int']['output']>;
    updateCity: ICity;
    updateCountry: ICountry;
    updateState: IState;
};
export type IMutationCreateCityArgs = {
    propertyCity: ICityInput;
};
export type IMutationCreateCountryArgs = {
    country: ICountryInput;
};
export type IMutationCreateStateArgs = {
    state: IStateInput;
};
export type IMutationDeleteCityArgs = {
    id: Scalars['ID']['input'];
};
export type IMutationDeleteCountryArgs = {
    id: Scalars['ID']['input'];
};
export type IMutationDeleteStateArgs = {
    id: Scalars['ID']['input'];
};
export type IMutationUpdateCityArgs = {
    id: Scalars['ID']['input'];
    propertyCity: ICityUpdateInput;
};
export type IMutationUpdateCountryArgs = {
    country: ICountryInput;
    id: Scalars['ID']['input'];
};
export type IMutationUpdateStateArgs = {
    id: Scalars['ID']['input'];
    state: IStateUpdateInput;
};
/** An object with an ID. */
export type INode = {
    /** The ID of the node. */
    id: Scalars['ID']['output'];
};
export type IPageInfo = {
    __typename?: 'PageInfo';
    hasNextPage: Scalars['Boolean']['output'];
};
export type IQuery = {
    __typename?: 'Query';
    cities: ICities;
    city: ICity;
    countries: ICountries;
    country: ICountry;
    countryByName: ICountry;
    /** Looks up a node by ID. */
    node?: Maybe<INode>;
    state: IState;
    states: IStates;
};
export type IQueryCitiesArgs = {
    input?: InputMaybe<ICitiesInput>;
};
export type IQueryCityArgs = {
    id: Scalars['ID']['input'];
};
export type IQueryCountriesArgs = {
    criteria?: InputMaybe<Scalars['AnyObject']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    skip?: InputMaybe<Scalars['Int']['input']>;
    sort?: InputMaybe<ISort>;
};
export type IQueryCountryArgs = {
    id: Scalars['ID']['input'];
};
export type IQueryCountryByNameArgs = {
    name: Scalars['String']['input'];
};
export type IQueryNodeArgs = {
    id: Scalars['ID']['input'];
};
export type IQueryStateArgs = {
    id: Scalars['ID']['input'];
};
export type IQueryStatesArgs = {
    criteria?: InputMaybe<Scalars['AnyObject']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    skip?: InputMaybe<Scalars['Int']['input']>;
    sort?: InputMaybe<ISort>;
};
export type ISort = {
    key: Scalars['String']['input'];
    value: ISortEnum;
};
export declare enum ISortEnum {
    Asc = "ASC",
    Desc = "DESC"
}
/** Address State */
export type IState = IITerritorialState & {
    __typename?: 'State';
    cities: ICities;
    country: ICountry;
    createdAt: Scalars['DateTime']['output'];
    id: Scalars['ID']['output'];
    location?: Maybe<IGeoLocation>;
    name: Scalars['String']['output'];
    updatedAt: Scalars['DateTime']['output'];
};
/** Address State */
export type IStateCitiesArgs = {
    criteria?: InputMaybe<Scalars['AnyObject']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    skip?: InputMaybe<Scalars['Int']['input']>;
    sort?: InputMaybe<ISort>;
};
/** Address State Create Input */
export type IStateInput = {
    /** ID of Country to associate */
    country: Scalars['String']['input'];
    /** Name of the country to display */
    name: Scalars['String']['input'];
};
/** Address State Update Input */
export type IStateUpdateInput = {
    country: Scalars['String']['input'];
    name?: InputMaybe<Scalars['String']['input']>;
};
export type IStates = {
    __typename?: 'States';
    data?: Maybe<Array<Maybe<IState>>>;
    totalCount: Scalars['Int']['output'];
};
export type ISubscription = {
    __typename?: 'Subscription';
    dummy?: Maybe<Scalars['Int']['output']>;
};
/** Address State Create Input */
export type ITerritorialStateInput = {
    /** ID of Country to associate */
    country: Scalars['String']['input'];
    /** Name of the country to display */
    name: Scalars['String']['input'];
};
/** Address State Update Input */
export type ITerritorialStateUpdateInput = {
    country: Scalars['Int']['input'];
    name?: InputMaybe<Scalars['String']['input']>;
};
export type ResolverTypeWrapper<T> = Promise<T> | T;
export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
    resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
};
export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
export type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
    subscribe: SubscriptionSubscribeFn<{
        [key in TKey]: TResult;
    }, TParent, TContext, TArgs>;
    resolve?: SubscriptionResolveFn<TResult, {
        [key in TKey]: TResult;
    }, TContext, TArgs>;
}
export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
    subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
    resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
}
export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> = SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> = ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>) | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
export type NextResolverFn<T> = () => Promise<T>;
export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
/** Mapping of interface types */
export type IResolversInterfaceTypes<RefType extends Record<string, unknown>> = {
    ICity: (ICity);
    ICountry: (ICountry);
    IResourceUtilizationSettings: never;
    ITerritorialState: (IState);
    Node: never;
};
/** Mapping between all available schema types and the resolvers types */
export type IResolversTypes = {
    AdminIdeSettings: ResolverTypeWrapper<IAdminIdeSettings>;
    AnyObject: ResolverTypeWrapper<Scalars['AnyObject']['output']>;
    Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
    CacheControlScope: ICacheControlScope;
    Cities: ResolverTypeWrapper<ICities>;
    CitiesInput: ICitiesInput;
    CitiesOptions: ICitiesOptions;
    City: ResolverTypeWrapper<ICity>;
    CityInput: ICityInput;
    CityUpdateInput: ICityUpdateInput;
    Countries: ResolverTypeWrapper<ICountries>;
    Country: ResolverTypeWrapper<ICountry>;
    CountryInput: ICountryInput;
    Date: ResolverTypeWrapper<Scalars['Date']['output']>;
    DateTime: ResolverTypeWrapper<Scalars['DateTime']['output']>;
    EmptyResponse: ResolverTypeWrapper<IEmptyResponse>;
    FieldError: ResolverTypeWrapper<IFieldError>;
    Float: ResolverTypeWrapper<Scalars['Float']['output']>;
    GeoLocation: ResolverTypeWrapper<IGeoLocation>;
    GeoLocationInput: IGeoLocationInput;
    ICity: ResolverTypeWrapper<IResolversInterfaceTypes<IResolversTypes>['ICity']>;
    ICountry: ResolverTypeWrapper<IResolversInterfaceTypes<IResolversTypes>['ICountry']>;
    ID: ResolverTypeWrapper<Scalars['ID']['output']>;
    IResourceUtilizationSettings: ResolverTypeWrapper<IResolversInterfaceTypes<IResolversTypes>['IResourceUtilizationSettings']>;
    ITerritorialState: ResolverTypeWrapper<IResolversInterfaceTypes<IResolversTypes>['ITerritorialState']>;
    Int: ResolverTypeWrapper<Scalars['Int']['output']>;
    JSON: ResolverTypeWrapper<Scalars['JSON']['output']>;
    JSONObject: ResolverTypeWrapper<Scalars['JSONObject']['output']>;
    MailTemplateId: IMailTemplateId;
    MoleculerCronServiceName: IMoleculerCronServiceName;
    MoleculerServiceName: IMoleculerServiceName;
    Mutation: ResolverTypeWrapper<{}>;
    Node: ResolverTypeWrapper<IResolversInterfaceTypes<IResolversTypes>['Node']>;
    Observable: ResolverTypeWrapper<Scalars['Observable']['output']>;
    PageInfo: ResolverTypeWrapper<IPageInfo>;
    Query: ResolverTypeWrapper<{}>;
    Sort: ISort;
    SortEnum: ISortEnum;
    State: ResolverTypeWrapper<IState>;
    StateInput: IStateInput;
    StateUpdateInput: IStateUpdateInput;
    States: ResolverTypeWrapper<IStates>;
    String: ResolverTypeWrapper<Scalars['String']['output']>;
    Subscription: ResolverTypeWrapper<{}>;
    TerritorialStateInput: ITerritorialStateInput;
    TerritorialStateUpdateInput: ITerritorialStateUpdateInput;
    Time: ResolverTypeWrapper<Scalars['Time']['output']>;
    URI: ResolverTypeWrapper<Scalars['URI']['output']>;
    URIInput: ResolverTypeWrapper<Scalars['URIInput']['output']>;
};
/** Mapping between all available schema types and the resolvers parents */
export type IResolversParentTypes = {
    AdminIdeSettings: IAdminIdeSettings;
    AnyObject: Scalars['AnyObject']['output'];
    Boolean: Scalars['Boolean']['output'];
    Cities: ICities;
    CitiesInput: ICitiesInput;
    CitiesOptions: ICitiesOptions;
    City: ICity;
    CityInput: ICityInput;
    CityUpdateInput: ICityUpdateInput;
    Countries: ICountries;
    Country: ICountry;
    CountryInput: ICountryInput;
    Date: Scalars['Date']['output'];
    DateTime: Scalars['DateTime']['output'];
    EmptyResponse: IEmptyResponse;
    FieldError: IFieldError;
    Float: Scalars['Float']['output'];
    GeoLocation: IGeoLocation;
    GeoLocationInput: IGeoLocationInput;
    ICity: IResolversInterfaceTypes<IResolversParentTypes>['ICity'];
    ICountry: IResolversInterfaceTypes<IResolversParentTypes>['ICountry'];
    ID: Scalars['ID']['output'];
    IResourceUtilizationSettings: IResolversInterfaceTypes<IResolversParentTypes>['IResourceUtilizationSettings'];
    ITerritorialState: IResolversInterfaceTypes<IResolversParentTypes>['ITerritorialState'];
    Int: Scalars['Int']['output'];
    JSON: Scalars['JSON']['output'];
    JSONObject: Scalars['JSONObject']['output'];
    Mutation: {};
    Node: IResolversInterfaceTypes<IResolversParentTypes>['Node'];
    Observable: Scalars['Observable']['output'];
    PageInfo: IPageInfo;
    Query: {};
    Sort: ISort;
    State: IState;
    StateInput: IStateInput;
    StateUpdateInput: IStateUpdateInput;
    States: IStates;
    String: Scalars['String']['output'];
    Subscription: {};
    TerritorialStateInput: ITerritorialStateInput;
    TerritorialStateUpdateInput: ITerritorialStateUpdateInput;
    Time: Scalars['Time']['output'];
    URI: Scalars['URI']['output'];
    URIInput: Scalars['URIInput']['output'];
};
export type ICacheControlDirectiveArgs = {
    maxAge?: Maybe<Scalars['Int']['input']>;
    scope?: Maybe<ICacheControlScope>;
};
export type ICacheControlDirectiveResolver<Result, Parent, ContextType = any, Args = ICacheControlDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
export type IAdminIdeSettingsResolvers<ContextType = any, ParentType extends IResolversParentTypes['AdminIdeSettings'] = IResolversParentTypes['AdminIdeSettings']> = {
    dummy?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export interface IAnyObjectScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['AnyObject'], any> {
    name: 'AnyObject';
}
export type ICitiesResolvers<ContextType = any, ParentType extends IResolversParentTypes['Cities'] = IResolversParentTypes['Cities']> = {
    data?: Resolver<Maybe<Array<Maybe<IResolversTypes['City']>>>, ParentType, ContextType>;
    totalCount?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type ICityResolvers<ContextType = any, ParentType extends IResolversParentTypes['City'] = IResolversParentTypes['City']> = {
    createdAt?: Resolver<IResolversTypes['DateTime'], ParentType, ContextType>;
    id?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
    location?: Resolver<Maybe<IResolversTypes['GeoLocation']>, ParentType, ContextType>;
    name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
    state?: Resolver<IResolversTypes['State'], ParentType, ContextType>;
    updatedAt?: Resolver<IResolversTypes['DateTime'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type ICountriesResolvers<ContextType = any, ParentType extends IResolversParentTypes['Countries'] = IResolversParentTypes['Countries']> = {
    data?: Resolver<Maybe<Array<Maybe<IResolversTypes['Country']>>>, ParentType, ContextType>;
    totalCount?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type ICountryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Country'] = IResolversParentTypes['Country']> = {
    createdAt?: Resolver<IResolversTypes['DateTime'], ParentType, ContextType>;
    currency?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
    currency_symbol?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
    emoji?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
    id?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
    location?: Resolver<Maybe<IResolversTypes['GeoLocation']>, ParentType, ContextType>;
    name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
    phone_code?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
    states?: Resolver<Maybe<IResolversTypes['States']>, ParentType, ContextType, Partial<ICountryStatesArgs>>;
    updatedAt?: Resolver<IResolversTypes['DateTime'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export interface IDateScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Date'], any> {
    name: 'Date';
}
export interface IDateTimeScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['DateTime'], any> {
    name: 'DateTime';
}
export type IEmptyResponseResolvers<ContextType = any, ParentType extends IResolversParentTypes['EmptyResponse'] = IResolversParentTypes['EmptyResponse']> = {
    alwaysNil?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type IFieldErrorResolvers<ContextType = any, ParentType extends IResolversParentTypes['FieldError'] = IResolversParentTypes['FieldError']> = {
    field?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
    message?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type IGeoLocationResolvers<ContextType = any, ParentType extends IResolversParentTypes['GeoLocation'] = IResolversParentTypes['GeoLocation']> = {
    coordinates?: Resolver<Maybe<Array<Maybe<IResolversTypes['Float']>>>, ParentType, ContextType>;
    type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type IICityResolvers<ContextType = any, ParentType extends IResolversParentTypes['ICity'] = IResolversParentTypes['ICity']> = {
    __resolveType: TypeResolveFn<'City', ParentType, ContextType>;
    createdAt?: Resolver<IResolversTypes['DateTime'], ParentType, ContextType>;
    id?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
    location?: Resolver<Maybe<IResolversTypes['GeoLocation']>, ParentType, ContextType>;
    name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
    state?: Resolver<IResolversTypes['ITerritorialState'], ParentType, ContextType>;
    updatedAt?: Resolver<IResolversTypes['DateTime'], ParentType, ContextType>;
};
export type IICountryResolvers<ContextType = any, ParentType extends IResolversParentTypes['ICountry'] = IResolversParentTypes['ICountry']> = {
    __resolveType: TypeResolveFn<'Country', ParentType, ContextType>;
    createdAt?: Resolver<IResolversTypes['DateTime'], ParentType, ContextType>;
    currency?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
    currency_symbol?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
    emoji?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
    id?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
    location?: Resolver<Maybe<IResolversTypes['GeoLocation']>, ParentType, ContextType>;
    name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
    phone_code?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
    updatedAt?: Resolver<IResolversTypes['DateTime'], ParentType, ContextType>;
};
export type IIResourceUtilizationSettingsResolvers<ContextType = any, ParentType extends IResolversParentTypes['IResourceUtilizationSettings'] = IResolversParentTypes['IResourceUtilizationSettings']> = {
    __resolveType: TypeResolveFn<null, ParentType, ContextType>;
    adminApiNamespace?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
    subTopic?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
};
export type IITerritorialStateResolvers<ContextType = any, ParentType extends IResolversParentTypes['ITerritorialState'] = IResolversParentTypes['ITerritorialState']> = {
    __resolveType: TypeResolveFn<'State', ParentType, ContextType>;
    country?: Resolver<IResolversTypes['ICountry'], ParentType, ContextType>;
    createdAt?: Resolver<IResolversTypes['DateTime'], ParentType, ContextType>;
    id?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
    location?: Resolver<Maybe<IResolversTypes['GeoLocation']>, ParentType, ContextType>;
    name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
    updatedAt?: Resolver<IResolversTypes['DateTime'], ParentType, ContextType>;
};
export interface IJsonScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['JSON'], any> {
    name: 'JSON';
}
export interface IJsonObjectScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['JSONObject'], any> {
    name: 'JSONObject';
}
export type IMutationResolvers<ContextType = any, ParentType extends IResolversParentTypes['Mutation'] = IResolversParentTypes['Mutation']> = {
    createCity?: Resolver<IResolversTypes['City'], ParentType, ContextType, RequireFields<IMutationCreateCityArgs, 'propertyCity'>>;
    createCountry?: Resolver<IResolversTypes['Country'], ParentType, ContextType, RequireFields<IMutationCreateCountryArgs, 'country'>>;
    createState?: Resolver<IResolversTypes['State'], ParentType, ContextType, RequireFields<IMutationCreateStateArgs, 'state'>>;
    deleteCity?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationDeleteCityArgs, 'id'>>;
    deleteCountry?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationDeleteCountryArgs, 'id'>>;
    deleteState?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationDeleteStateArgs, 'id'>>;
    dummy?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
    updateCity?: Resolver<IResolversTypes['City'], ParentType, ContextType, RequireFields<IMutationUpdateCityArgs, 'id' | 'propertyCity'>>;
    updateCountry?: Resolver<IResolversTypes['Country'], ParentType, ContextType, RequireFields<IMutationUpdateCountryArgs, 'country' | 'id'>>;
    updateState?: Resolver<IResolversTypes['State'], ParentType, ContextType, RequireFields<IMutationUpdateStateArgs, 'id' | 'state'>>;
};
export type INodeResolvers<ContextType = any, ParentType extends IResolversParentTypes['Node'] = IResolversParentTypes['Node']> = {
    __resolveType: TypeResolveFn<null, ParentType, ContextType>;
    id?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
};
export interface IObservableScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Observable'], any> {
    name: 'Observable';
}
export type IPageInfoResolvers<ContextType = any, ParentType extends IResolversParentTypes['PageInfo'] = IResolversParentTypes['PageInfo']> = {
    hasNextPage?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type IQueryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
    cities?: Resolver<IResolversTypes['Cities'], ParentType, ContextType, Partial<IQueryCitiesArgs>>;
    city?: Resolver<IResolversTypes['City'], ParentType, ContextType, RequireFields<IQueryCityArgs, 'id'>>;
    countries?: Resolver<IResolversTypes['Countries'], ParentType, ContextType, Partial<IQueryCountriesArgs>>;
    country?: Resolver<IResolversTypes['Country'], ParentType, ContextType, RequireFields<IQueryCountryArgs, 'id'>>;
    countryByName?: Resolver<IResolversTypes['Country'], ParentType, ContextType, RequireFields<IQueryCountryByNameArgs, 'name'>>;
    node?: Resolver<Maybe<IResolversTypes['Node']>, ParentType, ContextType, RequireFields<IQueryNodeArgs, 'id'>>;
    state?: Resolver<IResolversTypes['State'], ParentType, ContextType, RequireFields<IQueryStateArgs, 'id'>>;
    states?: Resolver<IResolversTypes['States'], ParentType, ContextType, Partial<IQueryStatesArgs>>;
};
export type IStateResolvers<ContextType = any, ParentType extends IResolversParentTypes['State'] = IResolversParentTypes['State']> = {
    cities?: Resolver<IResolversTypes['Cities'], ParentType, ContextType, Partial<IStateCitiesArgs>>;
    country?: Resolver<IResolversTypes['Country'], ParentType, ContextType>;
    createdAt?: Resolver<IResolversTypes['DateTime'], ParentType, ContextType>;
    id?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
    location?: Resolver<Maybe<IResolversTypes['GeoLocation']>, ParentType, ContextType>;
    name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
    updatedAt?: Resolver<IResolversTypes['DateTime'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type IStatesResolvers<ContextType = any, ParentType extends IResolversParentTypes['States'] = IResolversParentTypes['States']> = {
    data?: Resolver<Maybe<Array<Maybe<IResolversTypes['State']>>>, ParentType, ContextType>;
    totalCount?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type ISubscriptionResolvers<ContextType = any, ParentType extends IResolversParentTypes['Subscription'] = IResolversParentTypes['Subscription']> = {
    dummy?: SubscriptionResolver<Maybe<IResolversTypes['Int']>, "dummy", ParentType, ContextType>;
};
export interface ITimeScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Time'], any> {
    name: 'Time';
}
export interface IUriScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['URI'], any> {
    name: 'URI';
}
export interface IUriInputScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['URIInput'], any> {
    name: 'URIInput';
}
export type IResolvers<ContextType = any> = {
    AdminIdeSettings?: IAdminIdeSettingsResolvers<ContextType>;
    AnyObject?: GraphQLScalarType;
    Cities?: ICitiesResolvers<ContextType>;
    City?: ICityResolvers<ContextType>;
    Countries?: ICountriesResolvers<ContextType>;
    Country?: ICountryResolvers<ContextType>;
    Date?: GraphQLScalarType;
    DateTime?: GraphQLScalarType;
    EmptyResponse?: IEmptyResponseResolvers<ContextType>;
    FieldError?: IFieldErrorResolvers<ContextType>;
    GeoLocation?: IGeoLocationResolvers<ContextType>;
    ICity?: IICityResolvers<ContextType>;
    ICountry?: IICountryResolvers<ContextType>;
    IResourceUtilizationSettings?: IIResourceUtilizationSettingsResolvers<ContextType>;
    ITerritorialState?: IITerritorialStateResolvers<ContextType>;
    JSON?: GraphQLScalarType;
    JSONObject?: GraphQLScalarType;
    Mutation?: IMutationResolvers<ContextType>;
    Node?: INodeResolvers<ContextType>;
    Observable?: GraphQLScalarType;
    PageInfo?: IPageInfoResolvers<ContextType>;
    Query?: IQueryResolvers<ContextType>;
    State?: IStateResolvers<ContextType>;
    States?: IStatesResolvers<ContextType>;
    Subscription?: ISubscriptionResolvers<ContextType>;
    Time?: GraphQLScalarType;
    URI?: GraphQLScalarType;
    URIInput?: GraphQLScalarType;
};
export type IDirectiveResolvers<ContextType = any> = {
    cacheControl?: ICacheControlDirectiveResolver<any, any, ContextType>;
};
