import { Observable } from 'rxjs';
/**
 * The rx-signals {@link Store} uses this type to uniquely identify behaviors representing a root-state behavior.
 * A `StateId<T>` does not make any use of the generic `T` itself, but is given this
 * parameter only as a trick to let Typescript infer and thus enforce the correct types.
 * Use the {@link getStateId} function to generate a corresponding ID.
 *
 * @template T - specifies the value-type for the corresponding behavior observable (type of the state)
 */
export type StateId<T> = symbol & {
    _rootStateType: T;
};
/**
 * The rx-signals {@link Store} uses this type to uniquely identify behaviors representing a derived-state behavior.
 * A `DerivedId<T> does not make any use of the generic `T` itself, but is given this
 * parameter only as a trick to let Typescript infer and thus enforce the correct types.
 * Use the {@link getDerivedId} function to generate a corresponding ID.
 *
 * @template T - specifies the value-type for the corresponding behavior observable
 */
export type DerivedId<T> = symbol & {
    _derivedStateType: T;
};
/**
 * The rx-signals {@link Store} uses this type for cases where either a {@link StateId} or a {@link DerivedId} is expected.
 *
 * @template T - specifies the value-type for the corresponding behavior observable
 */
export type BehaviorId<T> = StateId<T> | DerivedId<T>;
/**
 * The rx-signals {@link Store} uses this type to uniquely identify all of its events.
 * An `EventId<T>` does not make any use of the generic `T` itself, but is given this
 * parameter only as a trick to let Typescript infer and thus enforce the correct types.
 * Use the {@link getEventId} function to generate a corresponding ID.
 *
 * @template T - specifies the value-type for the corresponding event observable
 */
export type EventId<T> = symbol & {
    _eventType: T;
};
/**
 * `SignalId<T>` is the union type of `BehaviorId<T>` and `EventId<T>`, hence it
 * represents an identifier that corresponds either to a behavior or to an event.
 * You can use the typeguards {@link isBehaviorId} or {@link isEventId} to check the concrete
 * type of a `SignalId`.
 *
 * @template T - specifies the value-type for the corresponding observable
 */
export type SignalId<T> = BehaviorId<T> | EventId<T>;
/**
 * `ToSignalId<S>` is a utility type that equals `Signal<T>`, if `S extends SignalId<T>`, else `never`.
 *
 * ```ts
 *    ToSignalId<BehaviorId<number>> = SignalId<number>
 *    ToSignalId<EventId<string>> = SignalId<string>
 *    ToSignalId<number> = never
 * ```
 *
 * @template S - the generic argument to `ToSignalId`
 * @template T - the inferred generic parameter of `S`, if `S extends SignalId<T>`
 */
export type ToSignalId<S> = S extends SignalId<infer T> ? SignalId<T> : never;
/**
 * `ToBehaviorIdValueType<B>` is a utility type that equals `T`, if `B extends BehaviorId<T>`, else `never`.
 *
 * ```ts
 *    ToBehaviorIdValueType<BehaviorId<number>> = number
 *    ToBehaviorIdValueType<EventId<string>> = never
 * ```
 *
 * @template B - the generic argument to `ToBehaviorIdValueType`
 * @template T - the inferred generic parameter of `B`, if `B extends BehaviorId<T>`
 */
export type ToBehaviorIdValueType<B> = B extends BehaviorId<infer T> ? T : never;
/**
 * `ToEventIdValueType<E>` is a utility type that equals `T`, if `E extends EventId<T>`, else `never`.
 *
 * ```ts
 *    ToEventIdValueType<EventId<number>> = number
 *    ToEventIdValueType<BehaviorId<string>> = never
 * ```
 *
 * @template E - the generic argument to `ToEventIdValueType`
 * @template T - the inferred generic parameter of `E`, if `E extends EventId<T>`
 */
export type ToEventIdValueType<E> = E extends EventId<infer T> ? T : never;
/**
 * `ToSignalIdValueType<S>` is a utility type that equals `T`, if `S extends SignalId<T>`, else `never`.
 *
 * ```ts
 *    ToSignalIdValueType<EventId<number>> = number
 *    ToSignalIdValueType<EventId<string>> = string
 *    ToSignalIdValueType<number> = never
 * ```
 *
 * @template S - the generic argument to `ToSignalIdValueType`
 * @template T - the inferred generic parameter of `S`, if `S extends SignalId<T>`
 */
export type ToSignalIdValueType<S> = S extends SignalId<infer T> ? T : never;
/**
 * `ToObservableValueType<O>` is a utility type that equals `T`, if `O extends Observable<T>`, else `never`.
 *
 * ```ts
 *    ToObservableValueType<Observable<number>> = number
 *    ToObservableValueType<Observable<string>> = string
 *    ToObservableValueType<number> = never
 * ```
 *
 * @template O - the generic argument to `ToObservableValueType`
 * @template T - the inferred generic parameter of `O`, if `O extends Observable<T>`
 */
export type ToObservableValueType<O> = O extends Observable<infer T> ? T : never;
/**
 * The rx-signals `Store` uses this type to uniquely identify all of its result effects.
 * An `EffectId<InputType, ResultType, ErrorType>` does not make any use of the generic parameters itself,
 * but is given these parameters only as a trick to let Typescript infer and thus enforce the correct types.
 * Use the {@link getEffectId} function to generate a corresponding ID.
 *
 * @template InputType - specifies the type for the corresponding effects input
 * @template ResultType - specifies the type for the corresponding effects result
 * @template ErrorType - specifies the type error-type for the effect. Use never for effects that cannot error.
 */
export type EffectId<InputType, ResultType, ErrorType = unknown> = symbol & {
    _inputType: InputType;
    _resultType: ResultType;
    _errorType: ErrorType;
};
/**
 * Function to get a new, unique `StateId`.
 *
 * @template T - specifies the value-type for the corresponding behavior
 * @param {string} nameExtension - an optional extension to the symbol name (so the string representation). Usually, you don't need this, cause even for debugging purposes, you should use {@link Store.setIdName} and {@link Store.getIdName}.
 * @returns {StateId<T>}
 */
export declare const getStateId: <T>(nameExtension?: string) => StateId<T>;
/**
 * Function to get a new, unique `DerivedId`.
 *
 * @template T - specifies the value-type for the corresponding behavior
 * @param {string} nameExtension - an optional extension to the symbol name (so the string representation). Usually, you don't need this, cause even for debugging purposes, you should use {@link Store.setIdName} and {@link Store.getIdName}.
 * @returns {DerivedId<T>}
 */
export declare const getDerivedId: <T>(nameExtension?: string) => DerivedId<T>;
/**
 * Function to get a new, unique `EventId`.
 *
 * @template T - specifies the value-type for the corresponding event
 * @param {string} nameExtension - an optional extension to the symbol name (so the string representation). Usually, you don't need this, cause even for debugging purposes, you should use {@link Store.setIdName} and {@link Store.getIdName}.
 * @returns {EventId<T>}
 */
export declare const getEventId: <T>(nameExtension?: string) => EventId<T>;
/**
 * Function to get a new, unique `EffectId`.
 *
 * @template InputType - specifies the type for the corresponding effects input
 * @template ResultType - specifies the type for the corresponding effects result
 * @template ErrorType - specifies the type error-type for the effect. Use `never` for effects that cannot error.
 * @param {string} nameExtension - an optional extension to the symbol name (so the string representation). Usually you should not need this.
 * @returns {EventId<T>}
 */
export declare const getEffectId: <InputType, ResultType, ErrorType = unknown>(nameExtension?: string) => EffectId<InputType, ResultType, ErrorType>;
/**
 * Typeguard to check whether a given `SignalId` is a `StateId`.
 *
 * @template T - specifies the type for the corresponding signal
 * @param {Signal<T>} id - a signal identifier.
 * @returns {boolean}
 */
export declare const isStateId: <T>(id: SignalId<T>) => id is StateId<T>;
/**
 * Typeguard to check whether a given `SignalId` is a `DerivedId`.
 *
 * @template T - specifies the type for the corresponding signal
 * @param {Signal<T>} id - a signal identifier.
 * @returns {boolean}
 */
export declare const isDerivedId: <T>(id: SignalId<T>) => id is DerivedId<T>;
/**
 * Typeguard to check whether a given `SignalId` is a `BehaviorId`.
 *
 * @template T - specifies the type for the corresponding signal
 * @param {Signal<T>} id - a signal identifier.
 * @returns {boolean}
 */
export declare const isBehaviorId: <T>(id: SignalId<T>) => id is BehaviorId<T>;
/**
 * Typeguard to check whether a given `SignalId` is an `EventId`.
 *
 * @template T - specifies the type for the corresponding signal
 * @param {Signal<T>} id - a signal identifier.
 * @returns {boolean}
 */
export declare const isEventId: <T>(id: SignalId<T>) => id is EventId<T>;
/**
 * A constant representing the intentional absence of a value.
 * Even undefined and null are valid values, so these cannot be used to represent no-value.
 */
export declare const NO_VALUE: '$RX-SIGNALS-NO-VALUE$';
/**
 * The corresponding type for {@link NO_VALUE}
 */
export type NoValueType = typeof NO_VALUE;
/**
 * Typeguard to check if a value is NOT {@link NO_VALUE}
 */
export declare const isNotNoValueType: <T>(v: T) => v is Exclude<T, "$RX-SIGNALS-NO-VALUE$">;
/**
 * Typeguard to check if a value is {@link NO_VALUE}
 */
export declare const isNoValueType: (v: any) => v is "$RX-SIGNALS-NO-VALUE$";