@ludo.ninja/api-server-features
Version:
Visit [Pharos Production](https://pharosproduction.com) – the software development company specializing in high-load Web3 and DeFi projects. We deliver projects on time and within budget!
472 lines (471 loc) • 25 kB
TypeScript
import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
import * as Apollo from '@apollo/client';
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;
};
JSON: {
input: any;
output: any;
};
Long: {
input: any;
output: any;
};
};
export type IFeature = {
description?: Maybe<Scalars['String']['output']>;
featureId: Scalars['Int']['output'];
name: Scalars['String']['output'];
parameterized: Scalars['Boolean']['output'];
};
export type IFeaturePack = {
basic: Scalars['Boolean']['output'];
daysPeriod: Scalars['Int']['output'];
featurePackId: Scalars['String']['output'];
name: Scalars['String']['output'];
packedFeatures?: Maybe<Array<IPackedFeature>>;
price: Scalars['Float']['output'];
};
export declare enum IFeatureType {
AutoAirdropSubscription = "AUTO_AIRDROP_SUBSCRIPTION",
BuyWithLudoXp = "BUY_WITH_LUDO_XP",
HistoricCharts = "HISTORIC_CHARTS",
NormalKpis = "NORMAL_KPIS",
ProjectAlerts = "PROJECT_ALERTS",
ProjectMonitors = "PROJECT_MONITORS"
}
export type IMutation = {
buyFeaturePackForXp: Scalars['Boolean']['output'];
buyProjectAlertForXp: Scalars['Boolean']['output'];
buyProjectMonitorForXp: Scalars['Boolean']['output'];
setDummy: Scalars['String']['output'];
};
export type IMutationBuyFeaturePackForXpArgs = {
featurePackId: Scalars['String']['input'];
};
export type IPackedFeature = {
description?: Maybe<Scalars['String']['output']>;
featureId: Scalars['String']['output'];
featurePackId: Scalars['String']['output'];
name: Scalars['String']['output'];
param?: Maybe<Scalars['Int']['output']>;
usageLimit?: Maybe<Scalars['Int']['output']>;
};
export type IQuery = {
fetchFeaturePacks?: Maybe<Array<IFeaturePack>>;
fetchFeatures?: Maybe<Array<IFeature>>;
fetchUserFeatureUsage: IUserFeatureUsage;
getDummy: Scalars['String']['output'];
};
export type IQueryFetchUserFeatureUsageArgs = {
featureType: IFeatureType;
};
export type IUserFeaturePack = {
acquiredAt: Scalars['Long']['output'];
featurePackId: Scalars['String']['output'];
userId: Scalars['String']['output'];
};
export type IUserFeatureUsage = {
activeUntil: Scalars['Long']['output'];
featureType: IFeatureType;
usageLimit: Scalars['Int']['output'];
usages: Scalars['Int']['output'];
userId: Scalars['String']['output'];
};
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 between all available schema types and the resolvers types */
export type IResolversTypes = {
Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
Feature: ResolverTypeWrapper<IFeature>;
FeaturePack: ResolverTypeWrapper<IFeaturePack>;
FeatureType: IFeatureType;
Float: ResolverTypeWrapper<Scalars['Float']['output']>;
Int: ResolverTypeWrapper<Scalars['Int']['output']>;
JSON: ResolverTypeWrapper<Scalars['JSON']['output']>;
Long: ResolverTypeWrapper<Scalars['Long']['output']>;
Mutation: ResolverTypeWrapper<{}>;
PackedFeature: ResolverTypeWrapper<IPackedFeature>;
Query: ResolverTypeWrapper<{}>;
String: ResolverTypeWrapper<Scalars['String']['output']>;
UserFeaturePack: ResolverTypeWrapper<IUserFeaturePack>;
UserFeatureUsage: ResolverTypeWrapper<IUserFeatureUsage>;
};
/** Mapping between all available schema types and the resolvers parents */
export type IResolversParentTypes = {
Boolean: Scalars['Boolean']['output'];
Feature: IFeature;
FeaturePack: IFeaturePack;
Float: Scalars['Float']['output'];
Int: Scalars['Int']['output'];
JSON: Scalars['JSON']['output'];
Long: Scalars['Long']['output'];
Mutation: {};
PackedFeature: IPackedFeature;
Query: {};
String: Scalars['String']['output'];
UserFeaturePack: IUserFeaturePack;
UserFeatureUsage: IUserFeatureUsage;
};
export type IFeatureResolvers<ContextType = any, ParentType extends IResolversParentTypes['Feature'] = IResolversParentTypes['Feature']> = {
description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
featureId?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
parameterized?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type IFeaturePackResolvers<ContextType = any, ParentType extends IResolversParentTypes['FeaturePack'] = IResolversParentTypes['FeaturePack']> = {
basic?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
daysPeriod?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
featurePackId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
packedFeatures?: Resolver<Maybe<Array<IResolversTypes['PackedFeature']>>, ParentType, ContextType>;
price?: Resolver<IResolversTypes['Float'], ParentType, ContextType>;
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export interface IJsonScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['JSON'], any> {
name: 'JSON';
}
export interface ILongScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Long'], any> {
name: 'Long';
}
export type IMutationResolvers<ContextType = any, ParentType extends IResolversParentTypes['Mutation'] = IResolversParentTypes['Mutation']> = {
buyFeaturePackForXp?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationBuyFeaturePackForXpArgs, 'featurePackId'>>;
buyProjectAlertForXp?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
buyProjectMonitorForXp?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
setDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
};
export type IPackedFeatureResolvers<ContextType = any, ParentType extends IResolversParentTypes['PackedFeature'] = IResolversParentTypes['PackedFeature']> = {
description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
featureId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
featurePackId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
param?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
usageLimit?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type IQueryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
fetchFeaturePacks?: Resolver<Maybe<Array<IResolversTypes['FeaturePack']>>, ParentType, ContextType>;
fetchFeatures?: Resolver<Maybe<Array<IResolversTypes['Feature']>>, ParentType, ContextType>;
fetchUserFeatureUsage?: Resolver<IResolversTypes['UserFeatureUsage'], ParentType, ContextType, RequireFields<IQueryFetchUserFeatureUsageArgs, 'featureType'>>;
getDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
};
export type IUserFeaturePackResolvers<ContextType = any, ParentType extends IResolversParentTypes['UserFeaturePack'] = IResolversParentTypes['UserFeaturePack']> = {
acquiredAt?: Resolver<IResolversTypes['Long'], ParentType, ContextType>;
featurePackId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
userId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type IUserFeatureUsageResolvers<ContextType = any, ParentType extends IResolversParentTypes['UserFeatureUsage'] = IResolversParentTypes['UserFeatureUsage']> = {
activeUntil?: Resolver<IResolversTypes['Long'], ParentType, ContextType>;
featureType?: Resolver<IResolversTypes['FeatureType'], ParentType, ContextType>;
usageLimit?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
usages?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
userId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type IResolvers<ContextType = any> = {
Feature?: IFeatureResolvers<ContextType>;
FeaturePack?: IFeaturePackResolvers<ContextType>;
JSON?: GraphQLScalarType;
Long?: GraphQLScalarType;
Mutation?: IMutationResolvers<ContextType>;
PackedFeature?: IPackedFeatureResolvers<ContextType>;
Query?: IQueryResolvers<ContextType>;
UserFeaturePack?: IUserFeaturePackResolvers<ContextType>;
UserFeatureUsage?: IUserFeatureUsageResolvers<ContextType>;
};
export type IBuyFeaturePackForXpMutationVariables = Exact<{
featurePackId: Scalars['String']['input'];
}>;
export type IBuyFeaturePackForXpMutation = {
buyFeaturePackForXp: boolean;
};
export type IBuyProjectAlertForXpMutationVariables = Exact<{
[key: string]: never;
}>;
export type IBuyProjectAlertForXpMutation = {
buyProjectAlertForXp: boolean;
};
export type IBuyProjectMonitorForXpMutationVariables = Exact<{
[key: string]: never;
}>;
export type IBuyProjectMonitorForXpMutation = {
buyProjectMonitorForXp: boolean;
};
export type IFetchFeaturePacksQueryVariables = Exact<{
[key: string]: never;
}>;
export type IFetchFeaturePacksQuery = {
fetchFeaturePacks?: Array<{
featurePackId: string;
name: string;
price: number;
basic: boolean;
daysPeriod: number;
packedFeatures?: Array<{
featurePackId: string;
featureId: string;
name: string;
description?: string | null;
param?: number | null;
usageLimit?: number | null;
}> | null;
}> | null;
};
export type IFetchFeaturesQueryVariables = Exact<{
[key: string]: never;
}>;
export type IFetchFeaturesQuery = {
fetchFeatures?: Array<{
featureId: number;
name: string;
description?: string | null;
parameterized: boolean;
}> | null;
};
export type IFetchUserFeatureUsageQueryVariables = Exact<{
featureType: IFeatureType;
}>;
export type IFetchUserFeatureUsageQuery = {
fetchUserFeatureUsage: {
userId: string;
featureType: IFeatureType;
usageLimit: number;
usages: number;
activeUntil: any;
};
};
export declare const BuyFeaturePackForXpDocument: Apollo.DocumentNode;
export type IBuyFeaturePackForXpMutationFn = Apollo.MutationFunction<IBuyFeaturePackForXpMutation, IBuyFeaturePackForXpMutationVariables>;
/**
* __useBuyFeaturePackForXpMutation__
*
* To run a mutation, you first call `useBuyFeaturePackForXpMutation` within a React component and pass it any options that fit your needs.
* When your component renders, `useBuyFeaturePackForXpMutation` 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 [buyFeaturePackForXpMutation, { data, loading, error }] = useBuyFeaturePackForXpMutation({
* variables: {
* featurePackId: // value for 'featurePackId'
* },
* });
*/
export declare function useBuyFeaturePackForXpMutation(baseOptions?: Apollo.MutationHookOptions<IBuyFeaturePackForXpMutation, IBuyFeaturePackForXpMutationVariables>): Apollo.MutationTuple<IBuyFeaturePackForXpMutation, Exact<{
featurePackId: Scalars["String"]["input"];
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type BuyFeaturePackForXpMutationHookResult = ReturnType<typeof useBuyFeaturePackForXpMutation>;
export type BuyFeaturePackForXpMutationResult = Apollo.MutationResult<IBuyFeaturePackForXpMutation>;
export type BuyFeaturePackForXpMutationOptions = Apollo.BaseMutationOptions<IBuyFeaturePackForXpMutation, IBuyFeaturePackForXpMutationVariables>;
export declare const BuyProjectAlertForXpDocument: Apollo.DocumentNode;
export type IBuyProjectAlertForXpMutationFn = Apollo.MutationFunction<IBuyProjectAlertForXpMutation, IBuyProjectAlertForXpMutationVariables>;
/**
* __useBuyProjectAlertForXpMutation__
*
* To run a mutation, you first call `useBuyProjectAlertForXpMutation` within a React component and pass it any options that fit your needs.
* When your component renders, `useBuyProjectAlertForXpMutation` 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 [buyProjectAlertForXpMutation, { data, loading, error }] = useBuyProjectAlertForXpMutation({
* variables: {
* },
* });
*/
export declare function useBuyProjectAlertForXpMutation(baseOptions?: Apollo.MutationHookOptions<IBuyProjectAlertForXpMutation, IBuyProjectAlertForXpMutationVariables>): Apollo.MutationTuple<IBuyProjectAlertForXpMutation, Exact<{
[key: string]: never;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type BuyProjectAlertForXpMutationHookResult = ReturnType<typeof useBuyProjectAlertForXpMutation>;
export type BuyProjectAlertForXpMutationResult = Apollo.MutationResult<IBuyProjectAlertForXpMutation>;
export type BuyProjectAlertForXpMutationOptions = Apollo.BaseMutationOptions<IBuyProjectAlertForXpMutation, IBuyProjectAlertForXpMutationVariables>;
export declare const BuyProjectMonitorForXpDocument: Apollo.DocumentNode;
export type IBuyProjectMonitorForXpMutationFn = Apollo.MutationFunction<IBuyProjectMonitorForXpMutation, IBuyProjectMonitorForXpMutationVariables>;
/**
* __useBuyProjectMonitorForXpMutation__
*
* To run a mutation, you first call `useBuyProjectMonitorForXpMutation` within a React component and pass it any options that fit your needs.
* When your component renders, `useBuyProjectMonitorForXpMutation` 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 [buyProjectMonitorForXpMutation, { data, loading, error }] = useBuyProjectMonitorForXpMutation({
* variables: {
* },
* });
*/
export declare function useBuyProjectMonitorForXpMutation(baseOptions?: Apollo.MutationHookOptions<IBuyProjectMonitorForXpMutation, IBuyProjectMonitorForXpMutationVariables>): Apollo.MutationTuple<IBuyProjectMonitorForXpMutation, Exact<{
[key: string]: never;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type BuyProjectMonitorForXpMutationHookResult = ReturnType<typeof useBuyProjectMonitorForXpMutation>;
export type BuyProjectMonitorForXpMutationResult = Apollo.MutationResult<IBuyProjectMonitorForXpMutation>;
export type BuyProjectMonitorForXpMutationOptions = Apollo.BaseMutationOptions<IBuyProjectMonitorForXpMutation, IBuyProjectMonitorForXpMutationVariables>;
export declare const FetchFeaturePacksDocument: Apollo.DocumentNode;
/**
* __useFetchFeaturePacksQuery__
*
* To run a query within a React component, call `useFetchFeaturePacksQuery` and pass it any options that fit your needs.
* When your component renders, `useFetchFeaturePacksQuery` 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 } = useFetchFeaturePacksQuery({
* variables: {
* },
* });
*/
export declare function useFetchFeaturePacksQuery(baseOptions?: Apollo.QueryHookOptions<IFetchFeaturePacksQuery, IFetchFeaturePacksQueryVariables>): Apollo.InteropQueryResult<IFetchFeaturePacksQuery, Exact<{
[key: string]: never;
}>>;
export declare function useFetchFeaturePacksLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchFeaturePacksQuery, IFetchFeaturePacksQueryVariables>): Apollo.LazyQueryResultTuple<IFetchFeaturePacksQuery, Exact<{
[key: string]: never;
}>>;
export declare function useFetchFeaturePacksSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<IFetchFeaturePacksQuery, IFetchFeaturePacksQueryVariables>): Apollo.UseSuspenseQueryResult<IFetchFeaturePacksQuery | undefined, Exact<{
[key: string]: never;
}>>;
export type FetchFeaturePacksQueryHookResult = ReturnType<typeof useFetchFeaturePacksQuery>;
export type FetchFeaturePacksLazyQueryHookResult = ReturnType<typeof useFetchFeaturePacksLazyQuery>;
export type FetchFeaturePacksSuspenseQueryHookResult = ReturnType<typeof useFetchFeaturePacksSuspenseQuery>;
export type FetchFeaturePacksQueryResult = Apollo.QueryResult<IFetchFeaturePacksQuery, IFetchFeaturePacksQueryVariables>;
export declare const FetchFeaturesDocument: Apollo.DocumentNode;
/**
* __useFetchFeaturesQuery__
*
* To run a query within a React component, call `useFetchFeaturesQuery` and pass it any options that fit your needs.
* When your component renders, `useFetchFeaturesQuery` 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 } = useFetchFeaturesQuery({
* variables: {
* },
* });
*/
export declare function useFetchFeaturesQuery(baseOptions?: Apollo.QueryHookOptions<IFetchFeaturesQuery, IFetchFeaturesQueryVariables>): Apollo.InteropQueryResult<IFetchFeaturesQuery, Exact<{
[key: string]: never;
}>>;
export declare function useFetchFeaturesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchFeaturesQuery, IFetchFeaturesQueryVariables>): Apollo.LazyQueryResultTuple<IFetchFeaturesQuery, Exact<{
[key: string]: never;
}>>;
export declare function useFetchFeaturesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<IFetchFeaturesQuery, IFetchFeaturesQueryVariables>): Apollo.UseSuspenseQueryResult<IFetchFeaturesQuery | undefined, Exact<{
[key: string]: never;
}>>;
export type FetchFeaturesQueryHookResult = ReturnType<typeof useFetchFeaturesQuery>;
export type FetchFeaturesLazyQueryHookResult = ReturnType<typeof useFetchFeaturesLazyQuery>;
export type FetchFeaturesSuspenseQueryHookResult = ReturnType<typeof useFetchFeaturesSuspenseQuery>;
export type FetchFeaturesQueryResult = Apollo.QueryResult<IFetchFeaturesQuery, IFetchFeaturesQueryVariables>;
export declare const FetchUserFeatureUsageDocument: Apollo.DocumentNode;
/**
* __useFetchUserFeatureUsageQuery__
*
* To run a query within a React component, call `useFetchUserFeatureUsageQuery` and pass it any options that fit your needs.
* When your component renders, `useFetchUserFeatureUsageQuery` 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 } = useFetchUserFeatureUsageQuery({
* variables: {
* featureType: // value for 'featureType'
* },
* });
*/
export declare function useFetchUserFeatureUsageQuery(baseOptions: Apollo.QueryHookOptions<IFetchUserFeatureUsageQuery, IFetchUserFeatureUsageQueryVariables> & ({
variables: IFetchUserFeatureUsageQueryVariables;
skip?: boolean;
} | {
skip: boolean;
})): Apollo.InteropQueryResult<IFetchUserFeatureUsageQuery, Exact<{
featureType: IFeatureType;
}>>;
export declare function useFetchUserFeatureUsageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchUserFeatureUsageQuery, IFetchUserFeatureUsageQueryVariables>): Apollo.LazyQueryResultTuple<IFetchUserFeatureUsageQuery, Exact<{
featureType: IFeatureType;
}>>;
export declare function useFetchUserFeatureUsageSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<IFetchUserFeatureUsageQuery, IFetchUserFeatureUsageQueryVariables>): Apollo.UseSuspenseQueryResult<IFetchUserFeatureUsageQuery | undefined, Exact<{
featureType: IFeatureType;
}>>;
export type FetchUserFeatureUsageQueryHookResult = ReturnType<typeof useFetchUserFeatureUsageQuery>;
export type FetchUserFeatureUsageLazyQueryHookResult = ReturnType<typeof useFetchUserFeatureUsageLazyQuery>;
export type FetchUserFeatureUsageSuspenseQueryHookResult = ReturnType<typeof useFetchUserFeatureUsageSuspenseQuery>;
export type FetchUserFeatureUsageQueryResult = Apollo.QueryResult<IFetchUserFeatureUsageQuery, IFetchUserFeatureUsageQueryVariables>;