/// <reference types="react" />
import * as ApolloReactCommon from '@apollo/react-common';
import * as ApolloReactComponents from '@apollo/react-components';
import * as ApolloReactHooks from '@apollo/react-hooks';
export declare type Maybe<T> = T | null;
export declare type Exact<T extends {
    [key: string]: any;
}> = {
    [K in keyof T]: T[K];
};
export declare type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
/** All built-in and custom scalars, mapped to their actual values */
export declare type Scalars = {
    ID: string;
    String: string;
    Boolean: boolean;
    Int: number;
    Float: number;
    /** Date custom scalar type */
    Date: any;
    /** Mongo Object Id */
    ObjectId: any;
};
export declare type Pagination = {
    perPage?: Maybe<Scalars['Int']>;
    page?: Maybe<Scalars['Int']>;
};
export declare type Sort = {
    field?: Maybe<Scalars['String']>;
    order?: Maybe<Scalars['Int']>;
};
export declare type IntFilter = {
    EQ?: Maybe<Scalars['Int']>;
    GT?: Maybe<Scalars['Int']>;
    GTE?: Maybe<Scalars['Int']>;
    IN?: Maybe<Array<Maybe<Scalars['Int']>>>;
    ALL?: Maybe<Array<Maybe<Scalars['Int']>>>;
    LT?: Maybe<Scalars['Int']>;
    LTE?: Maybe<Scalars['Int']>;
    NE?: Maybe<Scalars['Int']>;
    NIN?: Maybe<Array<Maybe<Scalars['Int']>>>;
};
export declare type FloatFilter = {
    EQ?: Maybe<Scalars['Float']>;
    GT?: Maybe<Scalars['Float']>;
    GTE?: Maybe<Scalars['Float']>;
    IN?: Maybe<Array<Maybe<Scalars['Float']>>>;
    ALL?: Maybe<Array<Maybe<Scalars['Float']>>>;
    LT?: Maybe<Scalars['Float']>;
    LTE?: Maybe<Scalars['Float']>;
    NE?: Maybe<Scalars['Float']>;
    NIN?: Maybe<Array<Maybe<Scalars['Float']>>>;
};
export declare type StringFilter = {
    EQ?: Maybe<Scalars['String']>;
    GT?: Maybe<Scalars['String']>;
    GTE?: Maybe<Scalars['String']>;
    IN?: Maybe<Array<Maybe<Scalars['String']>>>;
    ALL?: Maybe<Array<Maybe<Scalars['String']>>>;
    LT?: Maybe<Scalars['String']>;
    LTE?: Maybe<Scalars['String']>;
    NE?: Maybe<Scalars['String']>;
    NIN?: Maybe<Array<Maybe<Scalars['String']>>>;
};
export declare type DateFilter = {
    EQ?: Maybe<Scalars['Date']>;
    GT?: Maybe<Scalars['Date']>;
    GTE?: Maybe<Scalars['Date']>;
    IN?: Maybe<Array<Maybe<Scalars['Date']>>>;
    ALL?: Maybe<Array<Maybe<Scalars['Date']>>>;
    LT?: Maybe<Scalars['Date']>;
    LTE?: Maybe<Scalars['Date']>;
    NE?: Maybe<Scalars['Date']>;
    NIN?: Maybe<Array<Maybe<Scalars['Date']>>>;
};
export declare type ObjectIdFilter = {
    EQ?: Maybe<Scalars['ObjectId']>;
    GT?: Maybe<Scalars['ObjectId']>;
    GTE?: Maybe<Scalars['ObjectId']>;
    IN?: Maybe<Array<Maybe<Scalars['ObjectId']>>>;
    ALL?: Maybe<Array<Maybe<Scalars['ObjectId']>>>;
    LT?: Maybe<Scalars['ObjectId']>;
    LTE?: Maybe<Scalars['ObjectId']>;
    NE?: Maybe<Scalars['ObjectId']>;
    NIN?: Maybe<Array<Maybe<Scalars['ObjectId']>>>;
};
export declare type Mountain = {
    __typename?: 'Mountain';
    id?: Maybe<Scalars['ObjectId']>;
    name?: Maybe<Scalars['String']>;
    meters?: Maybe<Scalars['Float']>;
    feet?: Maybe<Scalars['Float']>;
    location?: Maybe<Scalars['String']>;
};
export declare type Query = {
    __typename?: 'Query';
    empty?: Maybe<Scalars['String']>;
    findMountains: MountainPage;
    findMountainById?: Maybe<Mountain>;
    findMountainsByIds?: Maybe<Array<Maybe<Mountain>>>;
};
export declare type QueryFindMountainsArgs = {
    pagination?: Maybe<Pagination>;
    sort?: Maybe<Sort>;
    filter?: Maybe<MountainFilter>;
};
export declare type QueryFindMountainByIdArgs = {
    id: Scalars['ObjectId'];
};
export declare type QueryFindMountainsByIdsArgs = {
    ids: Array<Scalars['ObjectId']>;
};
export declare type Mutation = {
    __typename?: 'Mutation';
    empty?: Maybe<Scalars['String']>;
    insertMountain?: Maybe<Mountain>;
    insertManyMountains?: Maybe<Array<Maybe<Mountain>>>;
    updateMountain?: Maybe<Mountain>;
    updateManyMountains?: Maybe<Array<Maybe<Mountain>>>;
    removeMountain?: Maybe<Mountain>;
    removeManyMountains?: Maybe<Array<Maybe<Mountain>>>;
};
export declare type MutationInsertMountainArgs = {
    mountain: MountainInsert;
};
export declare type MutationInsertManyMountainsArgs = {
    mountains: Array<MountainInsert>;
};
export declare type MutationUpdateMountainArgs = {
    id: Scalars['ObjectId'];
    mountainSet?: Maybe<MountainSet>;
};
export declare type MutationUpdateManyMountainsArgs = {
    ids: Array<Scalars['ObjectId']>;
    mountainSet?: Maybe<MountainSet>;
};
export declare type MutationRemoveMountainArgs = {
    id: Scalars['ObjectId'];
};
export declare type MutationRemoveManyMountainsArgs = {
    ids: Array<Scalars['ObjectId']>;
};
export declare type MountainPage = {
    __typename?: 'MountainPage';
    total?: Maybe<Scalars['Int']>;
    data?: Maybe<Array<Maybe<Mountain>>>;
};
export declare type MountainFilter = {
    name?: Maybe<StringFilter>;
    meters?: Maybe<FloatFilter>;
    feet?: Maybe<FloatFilter>;
    location?: Maybe<StringFilter>;
};
export declare type MountainInsert = {
    name?: Maybe<Scalars['String']>;
    meters?: Maybe<Scalars['Float']>;
    feet?: Maybe<Scalars['Float']>;
    location?: Maybe<Scalars['String']>;
};
export declare type MountainSet = {
    name?: Maybe<Scalars['String']>;
    meters?: Maybe<Scalars['Float']>;
    feet?: Maybe<Scalars['Float']>;
    location?: Maybe<Scalars['String']>;
};
export declare type MountainFragment = ({
    __typename?: 'Mountain';
} & Pick<Mountain, 'id' | 'name' | 'meters' | 'feet' | 'location'>);
export declare type InsertMountainMutationVariables = Exact<{
    mountain: MountainInsert;
}>;
export declare type InsertMountainMutation = ({
    __typename?: 'Mutation';
} & {
    insertMountain?: Maybe<({
        __typename?: 'Mountain';
    } & MountainFragment)>;
});
export declare type InsertManyMountainMutationVariables = Exact<{
    mountains: Array<MountainInsert>;
}>;
export declare type InsertManyMountainMutation = ({
    __typename?: 'Mutation';
} & {
    insertManyMountains?: Maybe<Array<Maybe<({
        __typename?: 'Mountain';
    } & MountainFragment)>>>;
});
export declare type UpdateMountainMutationVariables = Exact<{
    id: Scalars['ObjectId'];
    mountainSet?: Maybe<MountainSet>;
}>;
export declare type UpdateMountainMutation = ({
    __typename?: 'Mutation';
} & {
    updateMountain?: Maybe<({
        __typename?: 'Mountain';
    } & MountainFragment)>;
});
export declare type UpdateManyMountainsMutationVariables = Exact<{
    ids: Array<Scalars['ObjectId']>;
    mountainSet?: Maybe<MountainSet>;
}>;
export declare type UpdateManyMountainsMutation = ({
    __typename?: 'Mutation';
} & {
    updateManyMountains?: Maybe<Array<Maybe<({
        __typename?: 'Mountain';
    } & MountainFragment)>>>;
});
export declare type RemoveMountainMutationVariables = Exact<{
    id: Scalars['ObjectId'];
}>;
export declare type RemoveMountainMutation = ({
    __typename?: 'Mutation';
} & {
    removeMountain?: Maybe<({
        __typename?: 'Mountain';
    } & MountainFragment)>;
});
export declare type RemoveManyMountainsMutationVariables = Exact<{
    ids: Array<Scalars['ObjectId']>;
}>;
export declare type RemoveManyMountainsMutation = ({
    __typename?: 'Mutation';
} & {
    removeManyMountains?: Maybe<Array<Maybe<({
        __typename?: 'Mountain';
    } & MountainFragment)>>>;
});
export declare type FindMountainByIdQueryVariables = Exact<{
    id: Scalars['ObjectId'];
}>;
export declare type FindMountainByIdQuery = ({
    __typename?: 'Query';
} & {
    findMountainById?: Maybe<({
        __typename?: 'Mountain';
    } & MountainFragment)>;
});
export declare type FindMountainsByIdsQueryVariables = Exact<{
    ids: Array<Scalars['ObjectId']>;
}>;
export declare type FindMountainsByIdsQuery = ({
    __typename?: 'Query';
} & {
    findMountainsByIds?: Maybe<Array<Maybe<({
        __typename?: 'Mountain';
    } & MountainFragment)>>>;
});
export declare type FindMountainsQueryVariables = Exact<{
    filter?: Maybe<MountainFilter>;
    pagination?: Maybe<Pagination>;
    sort?: Maybe<Sort>;
}>;
export declare type FindMountainsQuery = ({
    __typename?: 'Query';
} & {
    findMountains: ({
        __typename?: 'MountainPage';
    } & Pick<MountainPage, 'total'> & {
        data?: Maybe<Array<Maybe<({
            __typename?: 'Mountain';
        } & MountainFragment)>>>;
    });
});
export declare const MountainFragmentDoc: import("graphql").DocumentNode;
export declare const InsertMountainDocument: import("graphql").DocumentNode;
export declare type InsertMountainMutationFn = ApolloReactCommon.MutationFunction<InsertMountainMutation, InsertMountainMutationVariables>;
export declare type InsertMountainComponentProps = Omit<ApolloReactComponents.MutationComponentOptions<InsertMountainMutation, InsertMountainMutationVariables>, 'mutation'>;
export declare const InsertMountainComponent: (props: InsertMountainComponentProps) => JSX.Element;
/**
 * __useInsertMountainMutation__
 *
 * To run a mutation, you first call `useInsertMountainMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useInsertMountainMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [insertMountainMutation, { data, loading, error }] = useInsertMountainMutation({
 *   variables: {
 *      mountain: // value for 'mountain'
 *   },
 * });
 */
export declare function useInsertMountainMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<InsertMountainMutation, InsertMountainMutationVariables>): ApolloReactHooks.MutationTuple<InsertMountainMutation, Exact<{
    mountain: MountainInsert;
}>>;
export declare type InsertMountainMutationHookResult = ReturnType<typeof useInsertMountainMutation>;
export declare type InsertMountainMutationResult = ApolloReactCommon.MutationResult<InsertMountainMutation>;
export declare type InsertMountainMutationOptions = ApolloReactCommon.BaseMutationOptions<InsertMountainMutation, InsertMountainMutationVariables>;
export declare const InsertManyMountainDocument: import("graphql").DocumentNode;
export declare type InsertManyMountainMutationFn = ApolloReactCommon.MutationFunction<InsertManyMountainMutation, InsertManyMountainMutationVariables>;
export declare type InsertManyMountainComponentProps = Omit<ApolloReactComponents.MutationComponentOptions<InsertManyMountainMutation, InsertManyMountainMutationVariables>, 'mutation'>;
export declare const InsertManyMountainComponent: (props: InsertManyMountainComponentProps) => JSX.Element;
/**
 * __useInsertManyMountainMutation__
 *
 * To run a mutation, you first call `useInsertManyMountainMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useInsertManyMountainMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [insertManyMountainMutation, { data, loading, error }] = useInsertManyMountainMutation({
 *   variables: {
 *      mountains: // value for 'mountains'
 *   },
 * });
 */
export declare function useInsertManyMountainMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<InsertManyMountainMutation, InsertManyMountainMutationVariables>): ApolloReactHooks.MutationTuple<InsertManyMountainMutation, Exact<{
    mountains: MountainInsert[];
}>>;
export declare type InsertManyMountainMutationHookResult = ReturnType<typeof useInsertManyMountainMutation>;
export declare type InsertManyMountainMutationResult = ApolloReactCommon.MutationResult<InsertManyMountainMutation>;
export declare type InsertManyMountainMutationOptions = ApolloReactCommon.BaseMutationOptions<InsertManyMountainMutation, InsertManyMountainMutationVariables>;
export declare const UpdateMountainDocument: import("graphql").DocumentNode;
export declare type UpdateMountainMutationFn = ApolloReactCommon.MutationFunction<UpdateMountainMutation, UpdateMountainMutationVariables>;
export declare type UpdateMountainComponentProps = Omit<ApolloReactComponents.MutationComponentOptions<UpdateMountainMutation, UpdateMountainMutationVariables>, 'mutation'>;
export declare const UpdateMountainComponent: (props: UpdateMountainComponentProps) => JSX.Element;
/**
 * __useUpdateMountainMutation__
 *
 * To run a mutation, you first call `useUpdateMountainMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateMountainMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateMountainMutation, { data, loading, error }] = useUpdateMountainMutation({
 *   variables: {
 *      id: // value for 'id'
 *      mountainSet: // value for 'mountainSet'
 *   },
 * });
 */
export declare function useUpdateMountainMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateMountainMutation, UpdateMountainMutationVariables>): ApolloReactHooks.MutationTuple<UpdateMountainMutation, Exact<{
    id: any;
    mountainSet?: MountainSet | null | undefined;
}>>;
export declare type UpdateMountainMutationHookResult = ReturnType<typeof useUpdateMountainMutation>;
export declare type UpdateMountainMutationResult = ApolloReactCommon.MutationResult<UpdateMountainMutation>;
export declare type UpdateMountainMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateMountainMutation, UpdateMountainMutationVariables>;
export declare const UpdateManyMountainsDocument: import("graphql").DocumentNode;
export declare type UpdateManyMountainsMutationFn = ApolloReactCommon.MutationFunction<UpdateManyMountainsMutation, UpdateManyMountainsMutationVariables>;
export declare type UpdateManyMountainsComponentProps = Omit<ApolloReactComponents.MutationComponentOptions<UpdateManyMountainsMutation, UpdateManyMountainsMutationVariables>, 'mutation'>;
export declare const UpdateManyMountainsComponent: (props: UpdateManyMountainsComponentProps) => JSX.Element;
/**
 * __useUpdateManyMountainsMutation__
 *
 * To run a mutation, you first call `useUpdateManyMountainsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateManyMountainsMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateManyMountainsMutation, { data, loading, error }] = useUpdateManyMountainsMutation({
 *   variables: {
 *      ids: // value for 'ids'
 *      mountainSet: // value for 'mountainSet'
 *   },
 * });
 */
export declare function useUpdateManyMountainsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateManyMountainsMutation, UpdateManyMountainsMutationVariables>): ApolloReactHooks.MutationTuple<UpdateManyMountainsMutation, Exact<{
    ids: any[];
    mountainSet?: MountainSet | null | undefined;
}>>;
export declare type UpdateManyMountainsMutationHookResult = ReturnType<typeof useUpdateManyMountainsMutation>;
export declare type UpdateManyMountainsMutationResult = ApolloReactCommon.MutationResult<UpdateManyMountainsMutation>;
export declare type UpdateManyMountainsMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateManyMountainsMutation, UpdateManyMountainsMutationVariables>;
export declare const RemoveMountainDocument: import("graphql").DocumentNode;
export declare type RemoveMountainMutationFn = ApolloReactCommon.MutationFunction<RemoveMountainMutation, RemoveMountainMutationVariables>;
export declare type RemoveMountainComponentProps = Omit<ApolloReactComponents.MutationComponentOptions<RemoveMountainMutation, RemoveMountainMutationVariables>, 'mutation'>;
export declare const RemoveMountainComponent: (props: RemoveMountainComponentProps) => JSX.Element;
/**
 * __useRemoveMountainMutation__
 *
 * To run a mutation, you first call `useRemoveMountainMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveMountainMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [removeMountainMutation, { data, loading, error }] = useRemoveMountainMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useRemoveMountainMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<RemoveMountainMutation, RemoveMountainMutationVariables>): ApolloReactHooks.MutationTuple<RemoveMountainMutation, Exact<{
    id: any;
}>>;
export declare type RemoveMountainMutationHookResult = ReturnType<typeof useRemoveMountainMutation>;
export declare type RemoveMountainMutationResult = ApolloReactCommon.MutationResult<RemoveMountainMutation>;
export declare type RemoveMountainMutationOptions = ApolloReactCommon.BaseMutationOptions<RemoveMountainMutation, RemoveMountainMutationVariables>;
export declare const RemoveManyMountainsDocument: import("graphql").DocumentNode;
export declare type RemoveManyMountainsMutationFn = ApolloReactCommon.MutationFunction<RemoveManyMountainsMutation, RemoveManyMountainsMutationVariables>;
export declare type RemoveManyMountainsComponentProps = Omit<ApolloReactComponents.MutationComponentOptions<RemoveManyMountainsMutation, RemoveManyMountainsMutationVariables>, 'mutation'>;
export declare const RemoveManyMountainsComponent: (props: RemoveManyMountainsComponentProps) => JSX.Element;
/**
 * __useRemoveManyMountainsMutation__
 *
 * To run a mutation, you first call `useRemoveManyMountainsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveManyMountainsMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [removeManyMountainsMutation, { data, loading, error }] = useRemoveManyMountainsMutation({
 *   variables: {
 *      ids: // value for 'ids'
 *   },
 * });
 */
export declare function useRemoveManyMountainsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<RemoveManyMountainsMutation, RemoveManyMountainsMutationVariables>): ApolloReactHooks.MutationTuple<RemoveManyMountainsMutation, Exact<{
    ids: any[];
}>>;
export declare type RemoveManyMountainsMutationHookResult = ReturnType<typeof useRemoveManyMountainsMutation>;
export declare type RemoveManyMountainsMutationResult = ApolloReactCommon.MutationResult<RemoveManyMountainsMutation>;
export declare type RemoveManyMountainsMutationOptions = ApolloReactCommon.BaseMutationOptions<RemoveManyMountainsMutation, RemoveManyMountainsMutationVariables>;
export declare const FindMountainByIdDocument: import("graphql").DocumentNode;
export declare type FindMountainByIdComponentProps = Omit<ApolloReactComponents.QueryComponentOptions<FindMountainByIdQuery, FindMountainByIdQueryVariables>, 'query'> & ({
    variables: FindMountainByIdQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
});
export declare const FindMountainByIdComponent: (props: FindMountainByIdComponentProps) => JSX.Element;
/**
 * __useFindMountainByIdQuery__
 *
 * To run a query within a React component, call `useFindMountainByIdQuery` and pass it any options that fit your needs.
 * When your component renders, `useFindMountainByIdQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFindMountainByIdQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useFindMountainByIdQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<FindMountainByIdQuery, FindMountainByIdQueryVariables>): ApolloReactCommon.QueryResult<FindMountainByIdQuery, Exact<{
    id: any;
}>>;
export declare function useFindMountainByIdLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<FindMountainByIdQuery, FindMountainByIdQueryVariables>): ApolloReactHooks.QueryTuple<FindMountainByIdQuery, Exact<{
    id: any;
}>>;
export declare type FindMountainByIdQueryHookResult = ReturnType<typeof useFindMountainByIdQuery>;
export declare type FindMountainByIdLazyQueryHookResult = ReturnType<typeof useFindMountainByIdLazyQuery>;
export declare type FindMountainByIdQueryResult = ApolloReactCommon.QueryResult<FindMountainByIdQuery, FindMountainByIdQueryVariables>;
export declare const FindMountainsByIdsDocument: import("graphql").DocumentNode;
export declare type FindMountainsByIdsComponentProps = Omit<ApolloReactComponents.QueryComponentOptions<FindMountainsByIdsQuery, FindMountainsByIdsQueryVariables>, 'query'> & ({
    variables: FindMountainsByIdsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
});
export declare const FindMountainsByIdsComponent: (props: FindMountainsByIdsComponentProps) => JSX.Element;
/**
 * __useFindMountainsByIdsQuery__
 *
 * To run a query within a React component, call `useFindMountainsByIdsQuery` and pass it any options that fit your needs.
 * When your component renders, `useFindMountainsByIdsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFindMountainsByIdsQuery({
 *   variables: {
 *      ids: // value for 'ids'
 *   },
 * });
 */
export declare function useFindMountainsByIdsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<FindMountainsByIdsQuery, FindMountainsByIdsQueryVariables>): ApolloReactCommon.QueryResult<FindMountainsByIdsQuery, Exact<{
    ids: any[];
}>>;
export declare function useFindMountainsByIdsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<FindMountainsByIdsQuery, FindMountainsByIdsQueryVariables>): ApolloReactHooks.QueryTuple<FindMountainsByIdsQuery, Exact<{
    ids: any[];
}>>;
export declare type FindMountainsByIdsQueryHookResult = ReturnType<typeof useFindMountainsByIdsQuery>;
export declare type FindMountainsByIdsLazyQueryHookResult = ReturnType<typeof useFindMountainsByIdsLazyQuery>;
export declare type FindMountainsByIdsQueryResult = ApolloReactCommon.QueryResult<FindMountainsByIdsQuery, FindMountainsByIdsQueryVariables>;
export declare const FindMountainsDocument: import("graphql").DocumentNode;
export declare type FindMountainsComponentProps = Omit<ApolloReactComponents.QueryComponentOptions<FindMountainsQuery, FindMountainsQueryVariables>, 'query'>;
export declare const FindMountainsComponent: (props: FindMountainsComponentProps) => JSX.Element;
/**
 * __useFindMountainsQuery__
 *
 * To run a query within a React component, call `useFindMountainsQuery` and pass it any options that fit your needs.
 * When your component renders, `useFindMountainsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFindMountainsQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *      sort: // value for 'sort'
 *   },
 * });
 */
export declare function useFindMountainsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<FindMountainsQuery, FindMountainsQueryVariables>): ApolloReactCommon.QueryResult<FindMountainsQuery, Exact<{
    filter?: MountainFilter | null | undefined;
    pagination?: Pagination | null | undefined;
    sort?: Sort | null | undefined;
}>>;
export declare function useFindMountainsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<FindMountainsQuery, FindMountainsQueryVariables>): ApolloReactHooks.QueryTuple<FindMountainsQuery, Exact<{
    filter?: MountainFilter | null | undefined;
    pagination?: Pagination | null | undefined;
    sort?: Sort | null | undefined;
}>>;
export declare type FindMountainsQueryHookResult = ReturnType<typeof useFindMountainsQuery>;
export declare type FindMountainsLazyQueryHookResult = ReturnType<typeof useFindMountainsLazyQuery>;
export declare type FindMountainsQueryResult = ApolloReactCommon.QueryResult<FindMountainsQuery, FindMountainsQueryVariables>;