import * as Types from '../../global/types.generated';
import * as ApolloReactCommon from '@apollo/client';
import * as ApolloReactHooks from '@apollo/client';
export type UserFragment = {
    __typename?: 'User';
    avatarImage?: string | null;
    displayName?: string | null;
    publicAddress: string;
    id: string;
    authMethod: string;
};
export type GetUserQueryVariables = Types.Exact<{
    [key: string]: never;
}>;
export type GetUserQuery = {
    __typename?: 'Query';
    user?: {
        __typename?: 'User';
        avatarImage?: string | null;
        displayName?: string | null;
        publicAddress: string;
        id: string;
        authMethod: string;
    } | null;
};
export type UserAddMutationVariables = Types.Exact<{
    input: Types.UserAddInput;
}>;
export type UserAddMutation = {
    __typename?: 'Mutation';
    userAdd: {
        __typename?: 'User';
        avatarImage?: string | null;
        displayName?: string | null;
        publicAddress: string;
        id: string;
        authMethod: string;
    };
};
export type AvatarImageUploadMutationVariables = Types.Exact<{
    input: Types.Scalars['Upload'];
}>;
export type AvatarImageUploadMutation = {
    __typename?: 'Mutation';
    avatarImageUpload: {
        __typename?: 'ImageUploadResponse';
        url: string;
    };
};
export type RandomAnticAvatarImageUrlQueryVariables = Types.Exact<{
    userAddress: Types.Scalars['String'];
}>;
export type RandomAnticAvatarImageUrlQuery = {
    __typename?: 'Query';
    randomAnticAvatarImageUrl: string;
};
export declare const UserFragmentDoc: ApolloReactCommon.DocumentNode;
export declare const GetUserDocument: ApolloReactCommon.DocumentNode;
/**
 * __useGetUserQuery__
 *
 * To run a query within a React component, call `useGetUserQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetUserQuery` 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 } = useGetUserQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useGetUserQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<GetUserQuery, GetUserQueryVariables>): ApolloReactCommon.QueryResult<GetUserQuery, Types.Exact<{
    [key: string]: never;
}>>;
export declare function useGetUserLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<GetUserQuery, GetUserQueryVariables>): ApolloReactCommon.LazyQueryResultTuple<GetUserQuery, Types.Exact<{
    [key: string]: never;
}>>;
export type GetUserQueryHookResult = ReturnType<typeof useGetUserQuery>;
export type GetUserLazyQueryHookResult = ReturnType<typeof useGetUserLazyQuery>;
export type GetUserQueryResult = ApolloReactCommon.QueryResult<GetUserQuery, GetUserQueryVariables>;
export declare const UserAddDocument: ApolloReactCommon.DocumentNode;
export type UserAddMutationFn = ApolloReactCommon.MutationFunction<UserAddMutation, UserAddMutationVariables>;
/**
 * __useUserAddMutation__
 *
 * To run a mutation, you first call `useUserAddMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUserAddMutation` 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 [userAddMutation, { data, loading, error }] = useUserAddMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUserAddMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UserAddMutation, UserAddMutationVariables>): ApolloReactCommon.MutationTuple<UserAddMutation, Types.Exact<{
    input: Types.UserAddInput;
}>, ApolloReactCommon.DefaultContext, ApolloReactCommon.ApolloCache<any>>;
export type UserAddMutationHookResult = ReturnType<typeof useUserAddMutation>;
export type UserAddMutationResult = ApolloReactCommon.MutationResult<UserAddMutation>;
export type UserAddMutationOptions = ApolloReactCommon.BaseMutationOptions<UserAddMutation, UserAddMutationVariables>;
export declare const AvatarImageUploadDocument: ApolloReactCommon.DocumentNode;
export type AvatarImageUploadMutationFn = ApolloReactCommon.MutationFunction<AvatarImageUploadMutation, AvatarImageUploadMutationVariables>;
/**
 * __useAvatarImageUploadMutation__
 *
 * To run a mutation, you first call `useAvatarImageUploadMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAvatarImageUploadMutation` 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 [avatarImageUploadMutation, { data, loading, error }] = useAvatarImageUploadMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useAvatarImageUploadMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<AvatarImageUploadMutation, AvatarImageUploadMutationVariables>): ApolloReactCommon.MutationTuple<AvatarImageUploadMutation, Types.Exact<{
    input: any;
}>, ApolloReactCommon.DefaultContext, ApolloReactCommon.ApolloCache<any>>;
export type AvatarImageUploadMutationHookResult = ReturnType<typeof useAvatarImageUploadMutation>;
export type AvatarImageUploadMutationResult = ApolloReactCommon.MutationResult<AvatarImageUploadMutation>;
export type AvatarImageUploadMutationOptions = ApolloReactCommon.BaseMutationOptions<AvatarImageUploadMutation, AvatarImageUploadMutationVariables>;
export declare const RandomAnticAvatarImageUrlDocument: ApolloReactCommon.DocumentNode;
/**
 * __useRandomAnticAvatarImageUrlQuery__
 *
 * To run a query within a React component, call `useRandomAnticAvatarImageUrlQuery` and pass it any options that fit your needs.
 * When your component renders, `useRandomAnticAvatarImageUrlQuery` 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 } = useRandomAnticAvatarImageUrlQuery({
 *   variables: {
 *      userAddress: // value for 'userAddress'
 *   },
 * });
 */
export declare function useRandomAnticAvatarImageUrlQuery(baseOptions: ApolloReactHooks.QueryHookOptions<RandomAnticAvatarImageUrlQuery, RandomAnticAvatarImageUrlQueryVariables>): ApolloReactCommon.QueryResult<RandomAnticAvatarImageUrlQuery, Types.Exact<{
    userAddress: string;
}>>;
export declare function useRandomAnticAvatarImageUrlLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<RandomAnticAvatarImageUrlQuery, RandomAnticAvatarImageUrlQueryVariables>): ApolloReactCommon.LazyQueryResultTuple<RandomAnticAvatarImageUrlQuery, Types.Exact<{
    userAddress: string;
}>>;
export type RandomAnticAvatarImageUrlQueryHookResult = ReturnType<typeof useRandomAnticAvatarImageUrlQuery>;
export type RandomAnticAvatarImageUrlLazyQueryHookResult = ReturnType<typeof useRandomAnticAvatarImageUrlLazyQuery>;
export type RandomAnticAvatarImageUrlQueryResult = ApolloReactCommon.QueryResult<RandomAnticAvatarImageUrlQuery, RandomAnticAvatarImageUrlQueryVariables>;