import type { UnknownError } from '@livestore/common';
import type { LiveStoreEvent, LiveStoreSchema } from '@livestore/common/schema';
import type { Cause, OtelTracer, Scope } from '@livestore/utils/effect';
import { Context, Deferred, Effect, Layer } from '@livestore/utils/effect';
import type { LiveStoreContextProps } from '../store/create-store.ts';
import { DeferredStoreContext, LiveStoreContextRunning } from '../store/create-store.ts';
import type { LiveStoreContextRunning as LiveStoreContextRunningType, Queryable } from '../store/store-types.ts';
export declare const makeLiveStoreContext: <TSchema extends LiveStoreSchema, TContext = {}>({ schema, storeId, context, boot, adapter, disableDevtools, onBootStatus, batchUpdates, syncPayload, syncPayloadSchema, }: LiveStoreContextProps<TSchema, TContext>) => Effect.Effect<LiveStoreContextRunning["Type"], UnknownError | Cause.TimeoutException, DeferredStoreContext | Scope.Scope | OtelTracer.OtelTracer>;
/**
 * @deprecated Use `Store.Tag(schema, storeId)` instead for type-safe store contexts.
 *
 * @example Migration
 * ```ts
 * // Before
 * const layer = LiveStoreContextLayer({ schema, adapter, ... })
 *
 * // After
 * class MainStore extends Store.Tag(schema, 'main') {}
 * const layer = MainStore.layer({ adapter, ... })
 * ```
 */
export declare const LiveStoreContextLayer: <TSchema extends LiveStoreSchema, TContext = {}>(props: LiveStoreContextProps<TSchema, TContext>) => Layer.Layer<LiveStoreContextRunning, UnknownError | Cause.TimeoutException, OtelTracer.OtelTracer>;
/**
 * @deprecated Use `Store.Tag(schema, storeId)` and `MainStore.DeferredLayer` instead.
 */
export declare const LiveStoreContextDeferred: Layer.Layer<DeferredStoreContext, never, never>;
/** Branded type for unique store context identity */
declare const StoreContextTypeId: unique symbol;
/** Phantom type carrying schema and storeId information */
export interface StoreContextId<TSchema extends LiveStoreSchema, TStoreId extends string> {
    readonly [StoreContextTypeId]: {
        readonly schema: TSchema;
        readonly storeId: TStoreId;
    };
}
/** Phantom type for deferred store context */
declare const DeferredContextTypeId: unique symbol;
export interface DeferredContextId<TStoreId extends string> {
    readonly [DeferredContextTypeId]: {
        readonly storeId: TStoreId;
    };
}
/** Props for creating a store layer (schema and storeId are already provided) */
export type StoreLayerProps<TSchema extends LiveStoreSchema, TContext = {}> = Omit<LiveStoreContextProps<TSchema, TContext>, 'storeId' | 'schema'>;
/**
 * Type for a Store.Tag class. This is the return type of `Store.Tag(schema, storeId)`.
 * Can be extended as a class and is yieldable in Effect.gen.
 *
 * Note: This uses a type alias with a new() signature to make it extendable.
 */
/**
 * Type for a Store.Tag class. Uses self-referential identifier so that `yield*`
 * and method R channels resolve to the same type, enabling proper layer composition.
 *
 * Uses `interface` (not `type`) to allow the self-referential identifier without
 * triggering TS2456 (circular type alias).
 */
export interface StoreTagClass<TSchema extends LiveStoreSchema, TStoreId extends string> extends Context.Tag<StoreTagClass<TSchema, TStoreId>, LiveStoreContextRunningType<TSchema>> {
    /** Constructor signature (makes the type extendable as a class) */
    new (): Context.Tag<StoreTagClass<TSchema, TStoreId>, LiveStoreContextRunningType<TSchema>>;
    /** Tag identity type (from Context.Tag) */
    readonly Id: StoreTagClass<TSchema, TStoreId>;
    /** Service type (from Context.Tag) */
    readonly Type: LiveStoreContextRunningType<TSchema>;
    /** The LiveStore schema for this store */
    readonly schema: TSchema;
    /** Unique identifier for this store */
    readonly storeId: TStoreId;
    /** Creates a layer that initializes the store */
    layer<TContext>(props: StoreLayerProps<TSchema, TContext>): Layer.Layer<StoreTagClass<TSchema, TStoreId>, UnknownError | Cause.TimeoutException, OtelTracer.OtelTracer>;
    /** Deferred store tag for async initialization patterns */
    readonly Deferred: Context.Tag<DeferredContextId<TStoreId>, Deferred.Deferred<LiveStoreContextRunningType<TSchema>, UnknownError>>;
    /** Layer that provides the Deferred tag */
    readonly DeferredLayer: Layer.Layer<DeferredContextId<TStoreId>>;
    /** Layer that waits for Deferred and provides the running store */
    readonly fromDeferred: Layer.Layer<StoreTagClass<TSchema, TStoreId>, UnknownError, DeferredContextId<TStoreId>>;
    /** Query the store. Returns an Effect that yields the query result. */
    query<TResult>(query: Queryable<TResult>): Effect.Effect<TResult, never, StoreTagClass<TSchema, TStoreId>>;
    /** Commit events to the store. */
    commit(...eventInputs: LiveStoreEvent.Input.ForSchema<TSchema>[]): Effect.Effect<void, never, StoreTagClass<TSchema, TStoreId>>;
    /** Use the store with a callback function. */
    use<A, E, R>(f: (ctx: LiveStoreContextRunningType<TSchema>) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R | StoreTagClass<TSchema, TStoreId>>;
}
/**
 * Store utilities for Effect integration.
 *
 * @example
 * ```ts
 * import { Store } from '@livestore/livestore/effect'
 *
 * export class MainStore extends Store.Tag(schema, 'main') {}
 * ```
 */
export declare const Store: {
    /**
     * Create a typed store context class for use with Effect.
     * @see {@link makeStoreTag} for full documentation
     */
    Tag: <TSchema extends LiveStoreSchema, TStoreId extends string>(schema: TSchema, storeId: TStoreId) => StoreTagClass<TSchema, TStoreId>;
};
/**
 * @deprecated Use `Store.Tag(schema, storeId)` instead.
 *
 * @example Migration
 * ```ts
 * // Before
 * const MainStoreContext = makeStoreContext<typeof schema>()('main')
 * export const MainStore = MainStoreContext.Tag
 * export const MainStoreLayer = MainStoreContext.Layer
 *
 * // After
 * export class MainStore extends Store.Tag(schema, 'main') {}
 * // MainStore.layer({ ... }) for the layer
 * ```
 */
export interface StoreContext<TSchema extends LiveStoreSchema, TStoreId extends string> {
    readonly storeId: TStoreId;
    readonly Tag: Context.Tag<StoreContextId<TSchema, TStoreId>, LiveStoreContextRunningType<TSchema>>;
    readonly DeferredTag: Context.Tag<DeferredContextId<TStoreId>, Deferred.Deferred<LiveStoreContextRunningType<TSchema>, UnknownError>>;
    readonly Layer: <TContext = {}>(props: Omit<LiveStoreContextProps<TSchema, TContext>, 'storeId'>) => Layer.Layer<StoreContextId<TSchema, TStoreId>, UnknownError | Cause.TimeoutException, OtelTracer.OtelTracer>;
    readonly DeferredLayer: Layer.Layer<DeferredContextId<TStoreId>>;
    readonly fromDeferred: Layer.Layer<StoreContextId<TSchema, TStoreId>, UnknownError, DeferredContextId<TStoreId>>;
}
/**
 * @deprecated Use `Store.Tag(schema, storeId)` instead.
 *
 * @example Migration
 * ```ts
 * // Before
 * const MainStoreContext = makeStoreContext<typeof schema>()('main')
 *
 * // After
 * class MainStore extends Store.Tag(schema, 'main') {}
 * ```
 */
export declare const makeStoreContext: <TSchema extends LiveStoreSchema>() => <TStoreId extends string>(storeId: TStoreId) => StoreContext<TSchema, TStoreId>;
export {};
//# sourceMappingURL=LiveStore.d.ts.map