import { DataManager, ManagerResolvers } from './dataManagerService';
import { StorageState, GenericGraphQLStorageSource } from './dataStorageInternalService';
import { GraphQLRecordAssertion, GraphQLArgumentAssertion } from '../graphql/graphqlService';
import { NonNullableProps, RequiredDifference } from '../../utilities/types';
export declare class DataStorage<A extends GenericGraphQLStorageSource<A>> {
    private _internalManager;
    constructor(storeHydrate: StorageState<A>);
    /**
     * Beware: extreme typesafety below, careful changing this.
     *
     * The type inputs for this method are modelled to match the types derived from GraphQL introspection.
     * The first 3 describe types that are used by the manager to assert transformations for mutations,
     * for example, the create and update types require resolvers that can transform to the Query type.
     * The last input should be the full schema for the GraphQL object that the other types are related to.
     * It technically is never interacted with however it asserts that the former types are for the same schema
     * by extending a transformation of itself that requires anything that it does not possess that the
     * other 3 types do.  If it is truly the full schema of the same GraphQL object then
     * it will have all the fields of the former types, however if any of the former are for a different schema
     * then it will most likely be invalid for missing fields (unless the schemas look the exact same).
     *
     * The extensions for first 3 types are used to assert that even after transformation, the input type is still valid
     * to extend itself.  The assertion for example will transform functions as props into 'never', so if the given
     * input type has functions as props it can no longer extend its transformed variant that explicitely
     * says to never have the offending function prop.  This is used to assert that the given types are primitive
     * and/or have a UID property, that is, the given types are either a GraphQL mutation argument or flat GraphQL record.
     *
     * Technically this can all be turned off with any, so partial use of this is possible if the consumer
     * for example 'any'ed the FullBaseType.
     */
    createManagerForSchema<QueryType extends GraphQLRecordAssertion<QueryType>, CreateType extends GraphQLArgumentAssertion<CreateType>, UpdateType extends GraphQLRecordAssertion<UpdateType>, FullBaseType extends RequiredDifference<FullBaseType, NonNullableProps<Required<QueryType>> & NonNullableProps<Required<CreateType>> & NonNullableProps<Required<UpdateType>>>>(schema: keyof GenericGraphQLStorageSource<A>, contextId: string, resolvers: ManagerResolvers<QueryType, CreateType, UpdateType, A, FullBaseType>): DataManager<QueryType, CreateType, UpdateType, A, FullBaseType, import("../../utilities/types").MergeNonOptionalFieldsIntoSimilarType<CreateType, UpdateType>>;
    export(): StorageState<A>;
}
//# sourceMappingURL=dataStorageService.d.ts.map