import type { EmptyObject } from '../../../framework-types/BaseTypes';
import type { Constants } from './Constants';
import type { EventListenerEffectFactory } from './effects/EventListenerEffectFactory';
import type { createMetricsAtom } from './metrics/MetricsAtom';
import type { createNetworkSampleAtom, Type } from './metrics/network/NetworkSampleAtom';
import type { createArrayAtom } from './state/ArrayStateAtom';
import type { copyCodecs, createCodecMapAtom } from './state/codec-map/CodecMapAtom';
import type { createDataStreamAtom, DataStreamClearedError, DataStreamClosedError } from './state/data-stream/DataStreamAtom';
import type { createMapStateAtom } from './state/MapStateAtom';
import type { createPrimitiveAtom } from './state/PrimitiveAtom';
import type { createQueueAtom, QueueItemRemovedError } from './state/QueueAtom';
import type { StateEffectFactory } from './state/state-effect/StateEffectFactory';
import type { createStateMachineAtom, flushPendingUpdates, logTransitions } from './state/StateMachineAtom';
import type { CreateStoreEffectFactory } from './state/StoreEffectFactory';
import type { createStreamSectionAtom } from './state/stream-timeline/StreamSectionAtom';
import type { createStreamSequenceMapAtom } from './state/stream-timeline/StreamSequenceMapAtom';
import type { createStreamTimelineAtom } from './state/stream-timeline/StreamTimelineMapAtom';
import type { createTimelineAtom } from './state/timeline/TimelineAtom';
import type { createTimelineTrackerAtom } from './state/timeline/TimelineTrackerAtom';
import type { TechnologyExports } from './technology/Types';
import type { CoreUtils } from './utils/Types';
export declare enum CoreExportNames {
    Utils = "utils",
    Constants = "constants",
    CoreEffects = "core-effects",
    CoreStateAtoms = "core-state-atoms"
}
export type CoreExports = {
    [CoreExportNames.Utils]: CoreUtils;
    [CoreExportNames.Constants]: Constants;
    [CoreExportNames.CoreEffects]: CoreEffects;
    [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
} & TechnologyExports;
export type CoreDependencies = EmptyObject;
/**
 * The core effects that the player needs to function.
 *
 * The state effect is concerned with reacting to state changes for a given state atom.
 *
 * The store effect is concerned with tracking the state atoms across threads
 *
 * The event listener effect is what allows us to react to DOM element events.
 *
 * <button onclick='eval("sudo reboot")'>Click me for free money</button>
 */
export type CoreEffects = {
    StateEffectFactory: typeof StateEffectFactory;
    StoreEffectFactory: typeof CreateStoreEffectFactory;
    EventListenerEffectFactory: typeof EventListenerEffectFactory;
};
/**
 * The core state atoms make up the data structures on which the player as a whole, operates.
 *
 * This main object is designed to be exposed on the registry for easy access. It consists of the atom
 * creators for all the core state atoms, along with a number of predicates that can be used to test
 * various assertions.
 */
export type CoreStateAtoms = {
    createArrayAtom: typeof createArrayAtom;
    createMapStateAtom: typeof createMapStateAtom;
    createPrimitiveAtom: typeof createPrimitiveAtom;
    createTimelineAtom: typeof createTimelineAtom;
    createTimelineTrackerAtom: typeof createTimelineTrackerAtom;
    Queue: {
        createQueueAtom: typeof createQueueAtom;
        QueueItemRemovedError: typeof QueueItemRemovedError;
    };
    SegmentTimeline: {
        createStreamTimelineAtom: typeof createStreamTimelineAtom;
        createStreamSequenceMapAtom: typeof createStreamSequenceMapAtom;
        createStreamSectionAtom: typeof createStreamSectionAtom;
    };
    Metrics: {
        createMetricsAtom: typeof createMetricsAtom;
        network: {
            SampleType: typeof Type;
            createNetworkSampleAtom: typeof createNetworkSampleAtom;
        };
    };
    DataStream: {
        createDataStreamAtom: typeof createDataStreamAtom;
        DataStreamClosedError: typeof DataStreamClosedError;
        DataStreamClearedError: typeof DataStreamClearedError;
    };
    CodecMap: {
        createCodecMapAtom: typeof createCodecMapAtom;
        copyCodecs: typeof copyCodecs;
    };
    StateMachine: {
        createStateMachineAtom: typeof createStateMachineAtom;
        flushPendingUpdates: typeof flushPendingUpdates;
        logTransitions: typeof logTransitions;
    };
};
