import { ModelFactory } from '../../../core';
import { FutureResponse } from '../../services/future';
import { IFutureModel, IFutureModelOptions } from './future-types';
/**
 * Maps a `FutureResponse` DTO to an `IFutureModelOptions` object.
 *
 * @remarks
 * This function will perform any type conversion or data mapping required
 * by the IKosDataModel.  For example, date conversion or changes in interfaces
 * can be managed at this layer rather than having the models deal with the
 * various versions of the interface directly.
 *
 * @params dto - the Data Transfer Object received from the backend
 * @returns - a valid `IFutureModelOptions` that can be used to
 * instantiate a new model.
 * @internal
 * @category future
 */
export declare const mapDtoToFutureOptions: (dto: FutureResponse) => IFutureModelOptions<Record<string, unknown>>;
/**
 * Maps a `FutureResponse` DTO to an `IFutureModel` object.
 *
 * @remarks
 * This function will run as a mobx action ensuring that all observers are notified
 * if any changes are made.
 *
 * @params dto - the Data Transfer Object received from the backend
 * @params model - the IModel to be update
 * @internal
 * @category future
 */
export declare const mapDtoToFutureModel: (dto: FutureResponse, model: IFutureModel) => void;
/**
 * Curried function that will produce a function that can be used to retrieve or create
 * new instances of a `IFutureModel` given an ID and options.
 *
 * @remarks
 * This serves as a convenience allowing for models to consumers to use a shorthand method when
 * multiple models need to be created.
 * The first level of function will accept a KOS Model Factory and return a function that can accept a single
 * model ID parameter.  This will return a factory function that can accept a model options parameter and
 * instantiate a new instance of a model or retrieve a an existing model.
 *
 * @param factory - the model factory to be used
 * @returns - an instance of the `IFutureModel` that was either created
 * or retrieved from the KOS Model framework if already existing.
 *
 * @internal
 * @category future
 */
export declare const buildFutureModel: (factory: ModelFactory<IFutureModel, IFutureModelOptions>) => (modelId: string) => (futureOptions: IFutureModelOptions) => IFutureModel<Record<string, unknown>>;
/**
 * Factory function that simplifies the creation of a new model
 *
 * @remarks
 * This method will map the response object to an `IFutureModelOptions` instance and
 * construct a new instance of a model using the provided factory.  This will provide a shorthand
 * for consumers when creating instances of models and allows for additional operations to be performed
 * as part of the creation process.
 *
 * @example
 * // create a new (potentially static) instance of the factory that can be used throughout the code.
 * const buildFutureModel = buildFuture((FutureModel.Factory));
 *
 * // use the builder to create a new instance of the model from an options instance.
 * const future: IFutureResponse = someFunctionToGetResponseFromServer();
 * const futureModel = buildFutureModel(future);
 *
 * @param factory - The model factory that can be used to
 *
 * @internal
 * @category future
 */
export declare const buildFuture: (factory: ModelFactory<IFutureModel, IFutureModelOptions>) => (future: FutureResponse) => any;
//# sourceMappingURL=future-model-builder.d.ts.map