@chocbite/ts-lib-state 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1430 @@
+import * as _chocbite_ts_lib_result from '@chocbite/ts-lib-result';
+import { Option, Result, ResultOk, OptionSome, OptionNone } from '@chocbite/ts-lib-result';
+import * as _chocbite_ts_lib_svg from '@chocbite/ts-lib-svg';
+import { SVGFunc } from '@chocbite/ts-lib-svg';
+
+type StateArrayWrite<TYPE> = {
+    type: "write";
+    items: readonly TYPE[];
+} | {
+    type: "change";
+    index: number;
+    item: TYPE;
+} | {
+    type: "push";
+    items: readonly TYPE[];
+} | {
+    type: "unshift";
+    items: readonly TYPE[];
+} | {
+    type: "pop";
+} | {
+    type: "shift";
+} | {
+    type: "delete";
+    item: TYPE;
+} | {
+    type: "splice";
+    index: number;
+    delete_count: number;
+    items?: readonly TYPE[];
+};
+declare const StateArrayReadType: {
+    readonly added: "added";
+    readonly removed: "removed";
+    readonly changed: "changed";
+    readonly fresh: "fresh";
+};
+type StateArrayReadType = (typeof StateArrayReadType)[keyof typeof StateArrayReadType];
+interface StateArrayRead<TYPE> {
+    array: readonly TYPE[];
+    type: StateArrayReadType;
+    index: number;
+    items: readonly TYPE[];
+}
+type SAR<AT> = StateArrayRead<AT>;
+type SAW<AT> = StateArrayWrite<AT>;
+type ArraySetter<AT, RRT extends Result<SAR<AT>, string>, REL extends Option<StateRelated>> = (value: SAW<AT>, state: OwnerWS$7<AT, RRT, REL>, old?: RRT) => Result<void, string>;
+interface Owner$d<AT, RRT extends Result<SAR<AT>, string>, REL extends Option<StateRelated>> {
+    set(value: ResultOk<AT[]>): void;
+    set_ok(value: AT[]): void;
+    setter?: ArraySetter<AT, RRT, REL>;
+    get array(): readonly AT[];
+    readonly length: number;
+    readonly length_state: StateROS<number>;
+    at(index: number): AT | undefined;
+    set_index(index: number, value: AT): void;
+    push(...items: AT[]): number;
+    pop(): AT | undefined;
+    shift(): AT | undefined;
+    unshift(...items: AT[]): number;
+    splice(start: number, deleteCount?: number, ...items: AT[]): AT[];
+    delete(val: AT): void;
+    apply_read<B>(result: ResultOk<SAR<B>>, transform: (val: readonly B[], type: StateArrayReadType) => AT[]): void;
+}
+interface OwnerWS$7<AT, RRT extends Result<SAR<AT>, string>, REL extends Option<StateRelated>> extends Owner$d<AT, RRT, REL> {
+    setter: ArraySetter<AT, RRT, REL>;
+}
+type StateArraySyncROS<AT, REL extends Option<StateRelated> = Option<{}>> = StateROS<SAR<AT>, REL, SAW<AT>> & Owner$d<AT, ResultOk<SAR<AT>>, REL> & {
+    readonly state: StateArray<AT, REL>;
+    readonly read_only: StateArrayROS<AT, REL>;
+    readonly read_write?: StateArrayROSWS<AT, REL>;
+};
+type StateArraySyncROSWS<AT, REL extends Option<StateRelated> = Option<{}>> = StateROSWS<SAR<AT>, SAW<AT>, REL> & OwnerWS$7<AT, ResultOk<SAR<AT>>, REL> & {
+    readonly state: StateArray<AT, REL>;
+    readonly read_only: StateArrayROS<AT, REL>;
+    readonly read_write: StateArrayROSWS<AT, REL>;
+};
+type StateArraySyncRES<AT, REL extends Option<StateRelated> = Option<{}>> = StateRES<SAR<AT>, REL, SAW<AT>> & Owner$d<AT, ResultOk<SAR<AT>>, REL> & {
+    set_err(error: string): void;
+    readonly state: StateArray<AT, REL>;
+    readonly read_only: StateArrayRES<AT, REL>;
+    readonly read_write?: StateArrayRESWS<AT, REL>;
+};
+type StateArraySyncRESWS<AT, REL extends Option<StateRelated> = Option<{}>> = StateRESWS<SAR<AT>, SAW<AT>, REL> & OwnerWS$7<AT, ResultOk<SAR<AT>>, REL> & {
+    set_err(error: string): void;
+    readonly state: StateArray<AT, REL>;
+    readonly read_only: StateArrayRES<AT, REL>;
+    readonly read_write: StateArrayRESWS<AT, REL>;
+};
+declare function apply_read<AT>(array: AT[], read: StateArrayRead<AT>): AT[];
+declare function apply_read<AT, TAT = AT>(array: AT[], read: StateArrayRead<TAT>, transform: (value: TAT, index: number, array: readonly TAT[]) => AT): AT[];
+
+/**Function used to subscribe to state changes
+ * @template RT - The type of the state’s value when read.*/
+type StateSub<RRT extends Result<any, string>> = (value: RRT) => void;
+type StateInferResult<S extends State<any>> = S extends StateROA<infer RT> ? ResultOk<RT> : S extends StateREA<infer RT> ? Result<RT, string> : never;
+type StateInferType<S extends State<any>> = S extends State<infer RT> ? RT : never;
+type StateInferSub<S extends State<any>> = StateSub<StateInferResult<S>>;
+/**Map of values or states related to a state */
+type StateRelated = {
+    [key: string | symbol | number]: any;
+};
+interface StateHelper<WT, REL extends Option<StateRelated>> {
+    related?: () => REL;
+    limit?: (value: WT) => Result<WT, string>;
+    check?: (value: WT) => Result<WT, string>;
+}
+type StateSetREXWS<RT, S, WT = RT> = (value: WT, state: S, old?: Result<RT, string>) => Result<void, string>;
+declare const STATE_KEY: unique symbol;
+interface StateBase$1<RT, WT, REL extends Option<StateRelated>, RRT extends Result<RT, string>> {
+    [STATE_KEY]: true;
+    /**Is state guarenteed sync*/
+    readonly rsync: boolean;
+    /**Is state guarenteed OK*/
+    readonly rok: boolean;
+    /**Allows getting value of the state*/
+    then<T = RRT>(func: (value: RRT) => T | PromiseLike<T>): PromiseLike<T>;
+    /**Gets the current value of the state if state is sync*/
+    get?(): RRT;
+    /**Gets the value of the state without result, only works when state is OK */
+    ok?(): RT;
+    /**This adds a function as a subscriber to changes to the state
+     * @param update set true to update subscriber immediatly*/
+    sub<T = StateSub<RRT>>(func: StateSub<RRT>, update?: boolean): T;
+    /**This removes a function as a subscriber to the state*/
+    unsub<T = StateSub<RRT>>(func: T): T;
+    /**This returns related states if any*/
+    related(): REL;
+    /**Returns if the state is being used */
+    in_use(): this | undefined;
+    /**Returns if the state has a subscriber */
+    has(subscriber: StateSub<RRT>): this | undefined;
+    /**Returns if the state has a subscriber */
+    amount(): number;
+    /**Is state guarenteed writable*/
+    readonly writable: boolean;
+    /**Is state guarenteed sync for writes*/
+    readonly wsync?: boolean;
+    /** This attempts a write to the state, write is not guaranteed to succeed
+     * @returns promise of result with error for the write*/
+    write?(value: WT): Promise<Result<void, string>>;
+    /** This attempts a write to the state, write is not guaranteed to succeed, this sync method is available on sync states
+     * @returns result with error for the write*/
+    write_sync?(value: WT): Result<void, string>;
+    /**Limits given value to valid range if possible returns None if not possible */
+    limit?(value: WT): Result<WT, string>;
+    /**Checks if the value is valid and returns reason for invalidity */
+    check?(value: WT): Result<WT, string>;
+}
+interface REA$1<RT, REL extends Option<StateRelated>, WT> extends StateBase$1<RT, WT, REL, ResultOk<RT>> {
+    readonly rsync: false;
+    readonly rok: false;
+    readonly writable: false;
+    readonly wsync: false;
+}
+interface ROA$1<RT, REL extends Option<StateRelated>, WT> extends StateBase$1<RT, WT, REL, ResultOk<RT>> {
+    readonly rsync: false;
+    readonly rok: true;
+    readonly writable: false;
+    readonly wsync: false;
+}
+interface RES$1<RT, REL extends Option<StateRelated>, WT> extends StateBase$1<RT, WT, REL, Result<RT, string>> {
+    readonly rsync: true;
+    readonly rok: false;
+    get(): Result<RT, string>;
+    readonly writable: false;
+    readonly wsync: false;
+}
+interface ROS$1<RT, REL extends Option<StateRelated>, WT> extends StateBase$1<RT, WT, REL, ResultOk<RT>> {
+    readonly rsync: true;
+    readonly rok: true;
+    get(): ResultOk<RT>;
+    ok(): RT;
+    readonly writable: false;
+    readonly wsync: false;
+}
+interface REAWA<RT, WT, REL extends Option<StateRelated>> extends StateBase$1<RT, WT, REL, ResultOk<RT>> {
+    readonly rsync: false;
+    readonly rok: false;
+    readonly writable: true;
+    readonly wsync: false;
+    write(value: WT): Promise<Result<void, string>>;
+    limit(value: WT): Result<WT, string>;
+    check(value: WT): Result<WT, string>;
+}
+interface REAWS<RT, WT, REL extends Option<StateRelated>> extends StateBase$1<RT, WT, REL, ResultOk<RT>> {
+    readonly rsync: false;
+    readonly rok: false;
+    readonly writable: true;
+    readonly wsync: true;
+    write(value: WT): Promise<Result<void, string>>;
+    limit(value: WT): Result<WT, string>;
+    check(value: WT): Result<WT, string>;
+    write_sync(value: WT): Result<void, string>;
+}
+interface ROAWA<RT, WT, REL extends Option<StateRelated>> extends StateBase$1<RT, WT, REL, ResultOk<RT>> {
+    readonly rsync: false;
+    readonly rok: true;
+    readonly writable: true;
+    readonly wsync: false;
+    write(value: WT): Promise<Result<void, string>>;
+    limit(value: WT): Result<WT, string>;
+    check(value: WT): Result<WT, string>;
+}
+interface ROAWS<RT, WT, REL extends Option<StateRelated>> extends StateBase$1<RT, WT, REL, ResultOk<RT>> {
+    readonly rsync: false;
+    readonly rok: true;
+    readonly writable: true;
+    readonly wsync: true;
+    write(value: WT): Promise<Result<void, string>>;
+    limit(value: WT): Result<WT, string>;
+    check(value: WT): Result<WT, string>;
+    write_sync(value: WT): Result<void, string>;
+}
+interface RESWA<RT, WT, REL extends Option<StateRelated>> extends StateBase$1<RT, WT, REL, Result<RT, string>> {
+    readonly rsync: true;
+    readonly rok: false;
+    get(): Result<RT, string>;
+    readonly writable: true;
+    readonly wsync: false;
+    write(value: WT): Promise<Result<void, string>>;
+    limit(value: WT): Result<WT, string>;
+    check(value: WT): Result<WT, string>;
+}
+interface RESWS<RT, WT, REL extends Option<StateRelated>> extends StateBase$1<RT, WT, REL, Result<RT, string>> {
+    readonly rsync: true;
+    readonly rok: false;
+    get(): Result<RT, string>;
+    readonly writable: true;
+    readonly wsync: true;
+    write(value: WT): Promise<Result<void, string>>;
+    limit(value: WT): Result<WT, string>;
+    check(value: WT): Result<WT, string>;
+    write_sync(value: WT): Result<void, string>;
+}
+interface ROSWA<RT, WT, REL extends Option<StateRelated>> extends StateBase$1<RT, WT, REL, ResultOk<RT>> {
+    readonly rsync: true;
+    readonly rok: true;
+    get(): ResultOk<RT>;
+    ok(): RT;
+    readonly writable: true;
+    readonly wsync: false;
+    write(value: WT): Promise<Result<void, string>>;
+    limit(value: WT): Result<WT, string>;
+    check(value: WT): Result<WT, string>;
+}
+interface ROSWS<RT, WT, REL extends Option<StateRelated>> extends StateBase$1<RT, WT, REL, ResultOk<RT>> {
+    readonly rsync: true;
+    readonly rok: true;
+    get(): ResultOk<RT>;
+    ok(): RT;
+    readonly writable: true;
+    readonly wsync: true;
+    write(value: WT): Promise<Result<void, string>>;
+    limit(value: WT): Result<WT, string>;
+    check(value: WT): Result<WT, string>;
+    write_sync(value: WT): Result<void, string>;
+}
+type State<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateREA<RT, REL, WT> | StateROA<RT, REL, WT> | StateRES<RT, REL, WT> | StateROS<RT, REL, WT> | StateREAWA<RT, WT, REL> | StateREAWS<RT, WT, REL> | StateROAWA<RT, WT, REL> | StateROAWS<RT, WT, REL> | StateRESWA<RT, WT, REL> | StateRESWS<RT, WT, REL> | StateROSWA<RT, WT, REL> | StateROSWS<RT, WT, REL>;
+type StateREA<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = REA$1<RT, REL, WT> | StateREAWA<RT, WT, REL> | StateREAWS<RT, WT, REL> | StateROA<RT, REL, WT> | StateROS<RT, REL, WT> | StateRES<RT, REL, WT>;
+type StateROA<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = ROA$1<RT, REL, WT> | StateROAWA<RT, WT, REL> | StateROAWS<RT, WT, REL> | StateROS<RT, REL, WT>;
+type StateRES<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = RES$1<RT, REL, WT> | StateRESWA<RT, WT, REL> | StateRESWS<RT, WT, REL> | StateROS<RT, REL, WT>;
+type StateROS<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = ROS$1<RT, REL, WT> | StateROSWA<RT, WT, REL> | StateROSWS<RT, WT, REL>;
+type StateREAWA<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = REAWA<RT, WT, REL> | StateREAWS<RT, WT, REL> | StateROAWA<RT, WT, REL> | StateROSWA<RT, WT, REL> | StateRESWA<RT, WT, REL>;
+type StateREAWS<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = REAWS<RT, WT, REL> | StateROAWS<RT, WT, REL> | StateROSWS<RT, WT, REL> | StateRESWS<RT, WT, REL>;
+type StateROAWA<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = ROAWA<RT, WT, REL> | StateROAWS<RT, WT, REL> | StateROSWA<RT, WT, REL>;
+type StateROAWS<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = ROAWS<RT, WT, REL> | StateROSWS<RT, WT, REL>;
+type StateRESWA<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = RESWA<RT, WT, REL> | StateRESWS<RT, WT, REL> | StateROSWA<RT, WT, REL>;
+type StateRESWS<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = RESWS<RT, WT, REL> | StateROSWS<RT, WT, REL>;
+type StateROSWA<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = ROSWA<RT, WT, REL> | StateROSWS<RT, WT, REL>;
+type StateROSWS<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = ROSWS<RT, WT, REL>;
+type StateArray<AT, REL extends Option<StateRelated> = Option<{}>> = State<StateArrayRead<AT>, StateArrayWrite<AT>, REL>;
+type StateArrayREA<AT, REL extends Option<StateRelated> = Option<{}>> = StateREA<StateArrayRead<AT>, REL, StateArrayWrite<AT>>;
+type StateArrayROA<AT, REL extends Option<StateRelated> = Option<{}>> = StateROA<StateArrayRead<AT>, REL, StateArrayWrite<AT>>;
+type StateArrayRES<AT, REL extends Option<StateRelated> = Option<{}>> = StateRES<StateArrayRead<AT>, REL, StateArrayWrite<AT>>;
+type StateArrayROS<AT, REL extends Option<StateRelated> = Option<{}>> = StateROS<StateArrayRead<AT>, REL, StateArrayWrite<AT>>;
+type StateArrayREAWS<AT, REL extends Option<StateRelated> = Option<{}>> = StateREAWS<StateArrayRead<AT>, StateArrayWrite<AT>, REL>;
+type StateArrayREAWA<AT, REL extends Option<StateRelated> = Option<{}>> = StateREAWA<StateArrayRead<AT>, StateArrayWrite<AT>, REL>;
+type StateArrayROAWS<AT, REL extends Option<StateRelated> = Option<{}>> = StateROAWS<StateArrayRead<AT>, StateArrayWrite<AT>, REL>;
+type StateArrayROAWA<AT, REL extends Option<StateRelated> = Option<{}>> = StateROAWA<StateArrayRead<AT>, StateArrayWrite<AT>, REL>;
+type StateArrayRESWS<AT, REL extends Option<StateRelated> = Option<{}>> = StateRESWS<StateArrayRead<AT>, StateArrayWrite<AT>, REL>;
+type StateArrayRESWA<AT, REL extends Option<StateRelated> = Option<{}>> = StateRESWA<StateArrayRead<AT>, StateArrayWrite<AT>, REL>;
+type StateArrayROSWS<AT, REL extends Option<StateRelated> = Option<{}>> = StateROSWS<StateArrayRead<AT>, StateArrayWrite<AT>, REL>;
+type StateArrayROSWA<AT, REL extends Option<StateRelated> = Option<{}>> = StateROSWA<StateArrayRead<AT>, StateArrayWrite<AT>, REL>;
+
+type SyncSetter<RT, RRT extends Result<RT, string>, REL extends Option<StateRelated>, WT = RT> = (value: WT, state: OwnerWS$6<RT, RRT, WT, REL>, old?: RRT) => Result<void, string>;
+interface Owner$c<RT, RRT extends Result<RT, string>, WT, REL extends Option<StateRelated>> {
+    set(value: RRT): void;
+    set_ok(value: RT): void;
+    setter?: SyncSetter<RT, RRT, REL, WT>;
+    readonly state: State<RT, WT, REL>;
+}
+interface OwnerWS$6<RT, RRT extends Result<RT, string>, WT, REL extends Option<StateRelated>> extends Owner$c<RT, RRT, WT, REL> {
+    setter: SyncSetter<RT, RRT, REL, WT>;
+}
+type StateSyncROS<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = StateROS<RT, REL, WT> & Owner$c<RT, ResultOk<RT>, WT, REL> & {
+    readonly read_only: StateROS<RT, REL, WT>;
+    readonly read_write?: StateROSWS<RT, WT, REL>;
+};
+type StateSyncROSWS<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateROSWS<RT, WT, REL> & OwnerWS$6<RT, ResultOk<RT>, WT, REL> & {
+    readonly read_only: StateROS<RT, REL, WT>;
+    readonly read_write: StateROSWS<RT, WT, REL>;
+};
+type StateSyncRES<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = StateRES<RT, REL, WT> & Owner$c<RT, Result<RT, string>, WT, REL> & {
+    set_err(error: string): void;
+    readonly read_only: StateRES<RT, REL, WT>;
+    readonly read_write?: StateRESWS<RT, WT, REL>;
+};
+type StateSyncRESWS<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateRESWS<RT, WT, REL> & OwnerWS$6<RT, Result<RT, string>, WT, REL> & {
+    set_err(error: string): void;
+    readonly read_only: StateRES<RT, REL, WT>;
+    readonly read_write: StateRESWS<RT, WT, REL>;
+};
+
+declare abstract class StateBase<RT, WT, REL extends Option<StateRelated>, RRT extends Result<RT, string>> implements StateBase$1<RT, WT, REL, RRT> {
+    #private;
+    get [STATE_KEY](): true;
+    abstract readonly rsync: boolean;
+    abstract readonly rok: boolean;
+    abstract then<T = RRT>(func: (value: RRT) => T | PromiseLike<T>): PromiseLike<T>;
+    get?(): RRT;
+    ok?(): RT;
+    sub<T = StateSub<RRT>>(func: StateSub<RRT>, update?: boolean): T;
+    unsub<T = StateSub<RRT>>(func: T): T;
+    abstract related(): REL;
+    in_use(): this | undefined;
+    has(subscriber: StateSub<RRT>): this | undefined;
+    amount(): number;
+    abstract readonly wsync: boolean;
+    abstract readonly writable: boolean;
+    write?(value: WT): Promise<Result<void, string>>;
+    limit?(value: WT): Result<WT, string>;
+    check?(value: WT): Result<WT, string>;
+    write_sync?(value: WT): Result<void, string>;
+    /**Called when subscriber is added*/
+    protected on_subscribe(): void;
+    /**Called when subscriber is removed*/
+    protected on_unsubscribe(): void;
+    /**Updates all subscribers with a value */
+    protected update_subs(value: RRT): void;
+    /**Creates a promise which can be fulfilled later with fulRProm */
+    protected append_r_prom<T = Result<RT, string>, TResult1 = Result<RT, string>>(func: (value: T) => TResult1 | PromiseLike<TResult1>): Promise<TResult1>;
+    /**Fulfills all read promises with given value */
+    protected ful_r_prom(value: RRT): RRT;
+}
+
+/**State Resource
+ * state for representing a remote resource
+ *
+ * Debounce and Timout
+ * example if the debounce is set to 50 and timeout to 200
+ * singleGet will not be called until 50 ms after the first await of the state
+ * when singleGet returns a Result, it is returned to all awaiters then buffered for the period of the timeout
+ * any awaiters within the timeout will get the buffer, after that it starts over
+ *
+ * Debounce and Retention
+ * When a subscriber is added the debounce delay is added before setupConnection is called
+ * likevise when the last subscriber unsubscribes the retention delay is added before teardownConnection is called
+ * this can prevent unneeded calls if the user is switching around quickly between things referencing states
+ * @template RT - The type of the state’s value when read.
+ * @template REL - The type of related states, defaults to an empty object.*/
+interface StateResourceOwnerREA<RT, WT, REL extends Option<StateRelated>> {
+    update_single(value: Result<RT, string>, update?: boolean): void;
+    update_resource(value: Result<RT, string>): void;
+    get buffer(): Result<RT, string> | undefined;
+    get state(): State<RT, WT, REL>;
+    get read_only(): StateREA<RT, REL, WT>;
+}
+declare abstract class StateResourceREA<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> extends StateBase<RT, WT, REL, Result<RT, string>> implements StateResourceOwnerREA<RT, WT, REL> {
+    #private;
+    /**Timeout before giving generic error, if update_resource is not called*/
+    abstract get timeout(): number;
+    /**Debounce delaying one time value retrival*/
+    abstract get debounce(): number;
+    /**Timeout for validity of last buffered value*/
+    abstract get validity(): number | true;
+    /**Retention delay before resource performs teardown of connection is performed*/
+    abstract get retention(): number;
+    protected on_subscribe(): void;
+    protected on_unsubscribe(): void;
+    /**Called if the state is awaited, returns the value once*/
+    protected abstract single_get(state: StateResourceOwnerREA<RT, WT, REL>): void;
+    /**Called when state is subscribed to to setup connection to remote resource*/
+    protected abstract setup_connection(state: StateResourceOwnerREA<RT, WT, REL>): void;
+    /**Called when state is no longer subscribed to to cleanup connection to remote resource*/
+    protected abstract teardown_connection(state: StateResourceOwnerREA<RT, WT, REL>): void;
+    update_single(value: Result<RT, string>, update?: boolean): void;
+    update_resource(value: Result<RT, string>): void;
+    get buffer(): Result<RT, string> | undefined;
+    get state(): State<RT, WT, REL>;
+    get read_only(): StateREA<RT, REL, WT>;
+    get rok(): false;
+    get rsync(): false;
+    then<T = Result<RT, string>>(func: (value: Result<RT, string>) => T | PromiseLike<T>): Promise<T>;
+    get writable(): boolean;
+    get wsync(): boolean;
+}
+interface Owner$b<RT, WT, REL extends Option<StateRelated>> extends StateResourceOwnerREA<RT, WT, REL> {
+}
+type StateResourceFuncREA<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = StateREA<RT, REL, WT> & Owner$b<RT, WT, REL>;
+/**State Resource
+ * state for representing a remote resource
+ *
+ * Debounce and Timout
+ * example if the debounce is set to 50 and timeout to 200
+ * singleGet will not be called until 50 ms after the first await of the state
+ * when singleGet returns a Result, it is returned to all awaiters then buffered for the period of the timeout
+ * any awaiters within the timeout will get the buffer, after that it starts over
+ *
+ * Debounce and Retention
+ * When a subscriber is added the debounce delay is added before setupConnection is called
+ * likevise when the last subscriber unsubscribes the retention delay is added before teardownConnection is called
+ * this can prevent unneeded calls if the user is switching around quickly between things referencing states
+ * @template RT - The type of the state’s value when read.
+ * @template WT - The type which can be written to the state.
+ * @template REL - The type of related states, defaults to an empty object.*/
+interface StateResourceOwnerREAWA<RT, WT, REL extends Option<StateRelated>> {
+    update_single(value: Result<RT, string>, update?: boolean): void;
+    update_resource(value: Result<RT, string>): void;
+    get buffer(): Result<RT, string> | undefined;
+    get state(): State<RT, WT, REL>;
+    get read_only(): StateREA<RT, REL, WT>;
+    get read_write(): StateREAWA<RT, WT, REL>;
+}
+declare abstract class StateResourceREAWA<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> extends StateBase<RT, WT, REL, Result<RT, string>> implements StateResourceOwnerREAWA<RT, WT, REL> {
+    #private;
+    /**Timeout before giving generic error, if update_resource is not called*/
+    abstract get timeout(): number;
+    /**Debounce delaying one time value retrival*/
+    abstract get debounce(): number;
+    /**Timeout for validity of last buffered value*/
+    abstract get validity(): number | true;
+    /**Retention delay before resource performs teardown of connection is performed*/
+    abstract get retention(): number;
+    /**How long to debounce write calls, before the last write call is used*/
+    abstract get write_debounce(): number;
+    protected on_subscribe(): void;
+    protected on_unsubscribe(): void;
+    /**Called if the state is awaited, returns the value once*/
+    protected abstract single_get(state: StateResourceOwnerREAWA<RT, WT, REL>): void;
+    /**Called when state is subscribed to to setup connection to remote resource*/
+    protected abstract setup_connection(state: StateResourceOwnerREAWA<RT, WT, REL>): void;
+    /**Called when state is no longer subscribed to to cleanup connection to remote resource*/
+    protected abstract teardown_connection(state: StateResourceOwnerREAWA<RT, WT, REL>): void;
+    /**Called after write debounce finished with the last written value*/
+    protected abstract write_action(value: WT, state: StateResourceOwnerREAWA<RT, WT, REL>): Promise<Result<void, string>>;
+    update_single(value: Result<RT, string>, update?: boolean): void;
+    update_resource(value: Result<RT, string>): void;
+    get buffer(): Result<RT, string> | undefined;
+    get state(): State<RT, WT, REL>;
+    get read_only(): StateREA<RT, REL, WT>;
+    get read_write(): StateREAWA<RT, WT, REL>;
+    get rok(): false;
+    get rsync(): false;
+    then<T = Result<RT, string>>(func: (value: Result<RT, string>) => T | PromiseLike<T>): Promise<T>;
+    get writable(): true;
+    get wsync(): false;
+    write(value: WT): Promise<Result<void, string>>;
+    abstract limit(value: WT): Result<WT, string>;
+    abstract check(value: WT): Result<WT, string>;
+}
+interface OwnerWA$5<RT, WT, REL extends Option<StateRelated>> extends StateResourceOwnerREAWA<RT, WT, REL> {
+}
+type StateResourceFuncREAWA<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = StateREAWA<RT, WT, REL> & OwnerWA$5<RT, WT, REL>;
+
+/**State Resource
+ * state for representing a remote resource
+ *
+ * Debounce and Timout
+ * example if the debounce is set to 50 and timeout to 200
+ * singleGet will not be called until 50 ms after the first await of the state
+ * when singleGet returns a Result, it is returned to all awaiters then buffered for the period of the timeout
+ * any awaiters within the timeout will get the buffer, after that it starts over
+ *
+ * Debounce and Retention
+ * When a subscriber is added the debounce delay is added before setupConnection is called
+ * likevise when the last subscriber unsubscribes the retention delay is added before teardownConnection is called
+ * this can prevent unneeded calls if the user is switching around quickly between things referencing states
+ * @template RT - The type of the state’s value when read.
+ * @template REL - The type of related states, defaults to an empty object.*/
+interface StateResourceOwnerROA<RT, WT, REL extends Option<StateRelated>> {
+    update_single(value: ResultOk<RT>, update?: boolean): void;
+    update_resource(value: ResultOk<RT>): void;
+    get buffer(): ResultOk<RT> | undefined;
+    get state(): State<RT, WT, REL>;
+    get read_only(): StateROA<RT, REL, WT>;
+}
+declare abstract class StateResourceROA<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> extends StateBase<RT, WT, REL, ResultOk<RT>> implements StateResourceOwnerROA<RT, WT, REL> {
+    #private;
+    /**Timeout before giving generic error, if update_resource is not called*/
+    abstract get timeout(): number;
+    /**Debounce delaying one time value retrival*/
+    abstract get debounce(): number;
+    /**Timeout for validity of last buffered value*/
+    abstract get validity(): number | true;
+    /**Retention delay before resource performs teardown of connection is performed*/
+    abstract get retention(): number;
+    protected on_subscribe(): void;
+    protected on_unsubscribe(): void;
+    /**Called if the state is awaited, returns the value once*/
+    protected abstract single_get(state: StateResourceOwnerROA<RT, WT, REL>): void;
+    /**Called when state is subscribed to to setup connection to remote resource*/
+    protected abstract setup_connection(state: StateResourceOwnerROA<RT, WT, REL>): void;
+    /**Called when state is no longer subscribed to to cleanup connection to remote resource*/
+    protected abstract teardown_connection(state: StateResourceOwnerROA<RT, WT, REL>): void;
+    update_single(value: ResultOk<RT>, update?: boolean): void;
+    update_resource(value: ResultOk<RT>): void;
+    get buffer(): ResultOk<RT> | undefined;
+    get state(): State<RT, WT, REL>;
+    get read_only(): StateROA<RT, REL, WT>;
+    get rok(): true;
+    get rsync(): false;
+    then<T = ResultOk<RT>>(func: (value: ResultOk<RT>) => T | PromiseLike<T>): Promise<T>;
+    get writable(): boolean;
+    get wsync(): boolean;
+}
+interface Owner$a<RT, WT, REL extends Option<StateRelated>> extends StateResourceOwnerROA<RT, WT, REL> {
+}
+type StateResourceFuncROA<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = StateROA<RT, REL, WT> & Owner$a<RT, WT, REL>;
+
+type LazySetter<RT, RRT extends Result<RT, string>, REL extends Option<StateRelated>, WT = RT> = (value: WT, state: OwnerWS$5<RT, RRT, WT, REL>, old?: RRT) => Result<void, string>;
+interface Owner$9<RT, RRT extends Result<RT, string>, WT, REL extends Option<StateRelated>> {
+    set(value: RRT): void;
+    set_ok(value: RT): void;
+    setter?: LazySetter<RT, RRT, REL, WT>;
+    readonly state: State<RT, WT, REL>;
+}
+interface OwnerWS$5<RT, RRT extends Result<RT, string>, WT, REL extends Option<StateRelated>> extends Owner$9<RT, RRT, WT, REL> {
+    setter: LazySetter<RT, RRT, REL, WT>;
+}
+type StateLazyROS<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = StateROS<RT, REL, WT> & Owner$9<RT, ResultOk<RT>, WT, REL> & {
+    readonly read_only: StateROS<RT, REL, WT>;
+    readonly read_write?: StateROSWS<RT, WT, REL>;
+};
+type StateLazyROSWS<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateROSWS<RT, WT, REL> & OwnerWS$5<RT, ResultOk<RT>, WT, REL> & {
+    readonly read_only: StateROS<RT, REL, WT>;
+    readonly read_write: StateROSWS<RT, WT, REL>;
+};
+type StateLazyRES<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = StateRES<RT, REL, WT> & Owner$9<RT, Result<RT, string>, WT, REL> & {
+    set_err(error: string): void;
+    readonly read_only: StateRES<RT, REL, WT>;
+    readonly read_write?: StateRESWS<RT, WT, REL>;
+};
+type StateLazyRESWS<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateRESWS<RT, WT, REL> & OwnerWS$5<RT, Result<RT, string>, WT, REL> & {
+    set_err(error: string): void;
+    readonly read_only: StateRES<RT, REL, WT>;
+    readonly read_write: StateRESWS<RT, WT, REL>;
+};
+
+interface StateNumberRelated extends StateRelated {
+    min?: number;
+    max?: number;
+    unit?: string;
+    decimals?: number;
+}
+declare class StateNumberHelper implements StateNumberRelated, StateHelper<number, OptionSome<StateNumberRelated>> {
+    min: number | undefined;
+    max: number | undefined;
+    unit: string | undefined;
+    decimals: number | undefined;
+    step: number | undefined;
+    start: number | undefined;
+    constructor(min?: number, max?: number, unit?: string, decimals?: number, step?: number, start?: number);
+    limit(value: number): Result<number, string>;
+    check(value: number): Result<number, string>;
+    related(): OptionSome<StateNumberRelated>;
+}
+interface StateStringRelated extends StateRelated {
+    max_length?: number;
+    max_length_bytes?: number;
+}
+declare class StateStringHelper implements StateStringRelated, StateHelper<string, OptionSome<StateStringRelated>> {
+    max_length: number | undefined;
+    max_length_bytes: number | undefined;
+    constructor(max_length?: number, max_length_bytes?: number);
+    limit(value: string): Result<string, string>;
+    check(value: string): Result<string, string>;
+    related(): OptionSome<StateStringRelated>;
+}
+type EnumHelperEntry = {
+    name: string;
+    description?: string;
+    icon?: SVGFunc;
+};
+type StateEnumHelperList<K extends PropertyKey> = {
+    [P in K]: EnumHelperEntry;
+};
+interface StateEnumRelated<L extends StateEnumHelperList<any>> extends StateRelated {
+    list: L;
+    map<K extends keyof L, R>(func: (key: K, val: EnumHelperEntry) => R): R[];
+}
+declare class StateEnumHelper<L extends StateEnumHelperList<any>, K extends PropertyKey = keyof L, R extends StateRelated = StateEnumRelated<L>> implements StateHelper<K, OptionSome<R>>, StateEnumRelated<L> {
+    list: L;
+    constructor(list: L);
+    map<K extends keyof L, R>(func: (key: K, val: EnumHelperEntry) => R): R[];
+    limit(value: K): Result<K, string>;
+    check(value: K): Result<K, string>;
+    related(): OptionSome<R>;
+}
+
+type DelayedSetterWS<RT, RRT extends Result<RT, string>, REL extends Option<StateRelated>, WT = RT> = (value: WT, state: OwnerWS$4<RT, RRT, WT, REL>, old?: RRT) => Result<void, string>;
+type DelayedSetterWA<RT, RRT extends Result<RT, string>, REL extends Option<StateRelated>, WT = RT> = (value: WT, state: OwnerWA$4<RT, RRT, WT, REL>, old?: RRT) => Promise<Result<void, string>>;
+interface Owner$8<RT, RRT extends Result<RT, string>, WT, REL extends Option<StateRelated>> {
+    set(value: RRT): void;
+    set_ok(value: RT): void;
+    setter_sync?: DelayedSetterWS<RT, RRT, REL, WT>;
+    setter_async?: DelayedSetterWA<RT, RRT, REL, WT>;
+    readonly state: State<RT, WT, REL>;
+}
+interface OwnerWS$4<RT, RRT extends Result<RT, string>, WT, REL extends Option<StateRelated>> extends Owner$8<RT, RRT, WT, REL> {
+    setter_sync: DelayedSetterWS<RT, RRT, REL, WT>;
+}
+interface OwnerWA$4<RT, RRT extends Result<RT, string>, WT, REL extends Option<StateRelated>> extends Owner$8<RT, RRT, WT, REL> {
+    setter_async: DelayedSetterWA<RT, RRT, REL, WT>;
+}
+type StateDelayedROA<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = StateROA<RT, REL, WT> & Owner$8<RT, ResultOk<RT>, WT, REL> & {
+    readonly read_only: StateROA<RT, REL, WT>;
+    readonly read_write_sync?: StateROAWS<RT, WT, REL>;
+    readonly read_write_async?: StateROAWA<RT, WT, REL>;
+};
+type StateDelayedROAWS<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateROAWS<RT, WT, REL> & OwnerWS$4<RT, ResultOk<RT>, WT, REL> & {
+    readonly read_only: StateROA<RT, REL, WT>;
+    readonly read_write_sync: StateROAWS<RT, WT, REL>;
+    readonly read_write_async?: StateROAWA<RT, WT, REL>;
+};
+type StateDelayedROAWA<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateROAWA<RT, WT, REL> & OwnerWA$4<RT, ResultOk<RT>, WT, REL> & {
+    readonly read_only: StateROA<RT, REL, WT>;
+    readonly read_write_sync?: StateROAWS<RT, WT, REL>;
+    readonly read_write_async: StateROAWA<RT, WT, REL>;
+};
+type StateDelayedREA<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = StateREA<RT, REL, WT> & Owner$8<RT, Result<RT, string>, WT, REL> & {
+    set_err(error: string): void;
+    readonly read_only: StateREA<RT, REL, WT>;
+    readonly read_write_sync?: StateREAWS<RT, WT, REL>;
+    readonly read_write_async?: StateREAWA<RT, WT, REL>;
+};
+type StateDelayedREAWS<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateREAWS<RT, WT, REL> & OwnerWS$4<RT, Result<RT, string>, WT, REL> & {
+    set_err(error: string): void;
+    readonly read_only: StateREA<RT, REL, WT>;
+    readonly read_write_sync: StateREAWS<RT, WT, REL>;
+    readonly read_write_async?: StateREAWA<RT, WT, REL>;
+};
+type StateDelayedREAWA<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateREAWA<RT, WT, REL> & OwnerWA$4<RT, Result<RT, string>, WT, REL> & {
+    set_err(error: string): void;
+    readonly read_only: StateREA<RT, REL, WT>;
+    readonly read_write_sync?: StateREAWS<RT, WT, REL>;
+    readonly read_write_async: StateREAWA<RT, WT, REL>;
+};
+
+type StateCollectedTransVal<IN extends State<any>[]> = {
+    [I in keyof IN]: StateInferResult<IN[I]>;
+};
+type StateCollectedStates<IN extends State<any>[]> = {
+    [I in keyof IN]: IN[I] extends StateROA<infer RT> ? StateROA<RT> : IN[I] extends StateREA<infer RT> ? StateREA<RT> : never;
+};
+
+interface Owner$7<RT, IN extends [StateRES<any>, ...StateRES<any>[]], WT> {
+    /**The `setStates` method is used to update the states used by the `StateDerived` class.
+     * @param states - The new states. This function should accept an array of states and return the derived state.*/
+    set_states(...states: StateCollectedStates<IN>): void;
+    /**The `setGetter` method is used to update the getter function used by the `StateDerived` class.
+     * This function is used to compute the derived state based on the current states.
+     * @param getter - The new getter function. This function should accept an array of states and return the derived state.*/
+    set_getter(getter: (values: StateCollectedTransVal<IN>) => ResultOk<RT>): void;
+    get state(): State<RT, WT, any>;
+    get read_only(): StateROS<RT, any, WT>;
+}
+type StateCollectedROS<RT, IN extends [StateRES<any>, ...StateRES<any>[]], WT = any> = StateROS<RT, OptionNone, WT> & Owner$7<RT, IN, WT>;
+declare class ROS<RT, IN extends [StateRES<any>, ...StateRES<any>[]], WT> extends StateBase<RT, WT, OptionNone, ResultOk<RT>> implements Owner$7<RT, IN, WT> {
+    #private;
+    constructor(transform: ((values: StateCollectedTransVal<IN>) => ResultOk<RT>) | false, ...states: IN);
+    protected getter(values: StateCollectedTransVal<IN>): ResultOk<RT>;
+    /**Called when subscriber is added*/
+    protected on_subscribe(): void;
+    /**Called when subscriber is removed*/
+    protected on_unsubscribe(): void;
+    set_states(...states: StateCollectedStates<IN>): void;
+    set_getter(getter: (values: StateCollectedTransVal<IN>) => ResultOk<RT>): void;
+    get state(): State<RT, WT, any>;
+    get read_only(): StateROS<RT, any, WT>;
+    get rok(): true;
+    get rsync(): true;
+    then<T = ResultOk<RT>>(func: (value: ResultOk<RT>) => T | PromiseLike<T>): Promise<T>;
+    get(): ResultOk<RT>;
+    ok(): RT;
+    related(): OptionNone;
+    get writable(): boolean;
+    get wsync(): boolean;
+}
+
+interface Owner$6<RT, IN extends [State<any>, ...State<any>[]], WT> {
+    /**The `setStates` method is used to update the states used by the `StateDerived` class.
+     * @param states - The new states. This function should accept an array of states and return the derived state.*/
+    set_states(...states: StateCollectedStates<IN>): void;
+    /**The `setGetter` method is used to update the getter function used by the `StateDerived` class.
+     * This function is used to compute the derived state based on the current states.
+     * @param getter - The new getter function. This function should accept an array of states and return the derived state.*/
+    set_getter(getter: (values: StateCollectedTransVal<IN>) => ResultOk<RT>): void;
+    get state(): State<RT, WT, any>;
+    get read_only(): StateROA<RT, any, WT>;
+}
+type StateCollectedROA<RT, IN extends [State<any>, ...State<any>[]], WT = any> = StateROA<RT, OptionNone, WT> & Owner$6<RT, IN, WT>;
+declare class ROA<RT, IN extends [State<any>, ...State<any>[]], WT> extends StateBase<RT, WT, OptionNone, ResultOk<RT>> implements Owner$6<RT, IN, WT> {
+    #private;
+    /**Creates a state which is derived from other states. The derived state will update when any of the other states update.
+     * @param transform - Function to translate value of state or states to something else, false means first states values is used.
+     * @param states - The other states to be used in the derived state.*/
+    constructor(transform: ((values: StateCollectedTransVal<IN>) => ResultOk<RT>) | false, ...states: IN);
+    protected getter(values: StateCollectedTransVal<IN>): ResultOk<RT>;
+    /**Called when subscriber is added*/
+    protected on_subscribe(): void;
+    /**Called when subscriber is removed*/
+    protected on_unsubscribe(): void;
+    set_states(...states: StateCollectedStates<IN>): void;
+    set_getter(getter: (values: StateCollectedTransVal<IN>) => ResultOk<RT>): void;
+    get state(): State<RT, WT, any>;
+    get read_only(): StateROA<RT, any, WT>;
+    get rok(): true;
+    get rsync(): false;
+    then<T = ResultOk<RT>>(func: (value: ResultOk<RT>) => T | PromiseLike<T>): Promise<T>;
+    related(): OptionNone;
+    get writable(): boolean;
+    get wsync(): boolean;
+}
+
+interface Owner$5<RT, IN extends StateRES<any>[], WT> {
+    /**The `setStates` method is used to update the states used by the `StateDerived` class.
+     * @param states - The new states. This function should accept an array of states and return the derived state.*/
+    set_states(...states: StateCollectedStates<IN>): void;
+    /**The `setGetter` method is used to update the getter function used by the `StateDerived` class.
+     * This function is used to compute the derived state based on the current states.
+     * @param getter - The new getter function. This function should accept an array of states and return the derived state.*/
+    set_getter(getter: (values: StateCollectedTransVal<IN>) => Result<RT, string>): void;
+    get state(): State<RT, WT, any>;
+    get read_only(): StateRES<RT, any, WT>;
+}
+type StateCollectedRES<RT, IN extends StateRES<any>[], WT = any> = StateRES<RT, OptionNone, WT> & Owner$5<RT, IN, WT>;
+declare class RES<RT, IN extends StateRES<any>[], WT> extends StateBase<RT, WT, OptionNone, Result<RT, string>> implements Owner$5<RT, IN, WT> {
+    #private;
+    /**Creates a state which is derived from other states. The derived state will update when any of the other states update.
+     * @param transform - Function to translate value of state or states to something else, false means first states values is used.
+     * @param states - The other states to be used in the derived state.*/
+    constructor(transform: ((values: StateCollectedTransVal<IN>) => Result<RT, string>) | false, ...states: IN);
+    protected getter(values: StateCollectedTransVal<IN>): Result<RT, string>;
+    /**Called when subscriber is added*/
+    protected on_subscribe(): void;
+    /**Called when subscriber is removed*/
+    protected on_unsubscribe(): void;
+    set_states(...states: StateCollectedStates<IN>): void;
+    set_getter(getter: (values: StateCollectedTransVal<IN>) => Result<RT, string>): void;
+    get state(): State<RT, WT, any>;
+    get read_only(): StateRES<RT, any, WT>;
+    get rok(): false;
+    get rsync(): true;
+    then<T = Result<RT, string>>(func: (value: Result<RT, string>) => T | PromiseLike<T>): Promise<T>;
+    get(): Result<RT, string>;
+    related(): OptionNone;
+    get writable(): boolean;
+    get wsync(): boolean;
+}
+
+interface Owner$4<RT, IN extends State<any>[], WT> {
+    /**The `setStates` method is used to update the states used by the `StateDerived` class.
+     * @param states - The new states. This function should accept an array of states and return the derived state.*/
+    set_states(...states: StateCollectedStates<IN>): void;
+    /**The `setGetter` method is used to update the getter function used by the `StateDerived` class.
+     * This function is used to compute the derived state based on the current states.
+     * @param getter - The new getter function. This function should accept an array of states and return the derived state.*/
+    set_getter(getter: (values: StateCollectedTransVal<IN>) => Result<RT, string>): void;
+    get state(): State<RT, WT, any>;
+    get read_only(): StateREA<RT, any, WT>;
+}
+type StateCollectedREA<RT, IN extends State<any>[], WT = any> = StateREA<RT, OptionNone, WT> & Owner$4<RT, IN, WT>;
+declare class REA<RT, IN extends State<any>[], WT> extends StateBase<RT, WT, OptionNone, Result<RT, string>> implements Owner$4<RT, IN, WT> {
+    #private;
+    constructor(transform: ((values: StateCollectedTransVal<IN>) => Result<RT, string>) | false, ...states: IN);
+    protected getter(values: StateCollectedTransVal<IN>): Result<RT, string>;
+    /**Called when subscriber is added*/
+    protected on_subscribe(): void;
+    /**Called when subscriber is removed*/
+    protected on_unsubscribe(): void;
+    set_states(...states: StateCollectedStates<IN>): void;
+    set_getter(getter: (values: StateCollectedTransVal<IN>) => Result<RT, string>): void;
+    get state(): State<RT, WT, any>;
+    get read_only(): StateREA<RT, any, WT>;
+    get rok(): false;
+    get rsync(): false;
+    then<T = Result<RT, string>>(func: (value: Result<RT, string>) => T | PromiseLike<T>): Promise<T>;
+    related(): OptionNone;
+    get writable(): boolean;
+    get wsync(): boolean;
+}
+
+interface Owner$3<S, RIN, ROUT, WIN, WOUT> {
+    /**Sets the state that is being proxied, and updates subscribers with new value*/
+    set_state(state: S): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_read(transform: (val: Result<RIN, string>) => Result<ROUT, string>): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_write(transform: (val: WOUT) => WIN): void;
+    get state(): State<ROUT, WOUT, OptionNone>;
+    get read_only(): StateREA<ROUT, OptionNone, WOUT>;
+}
+type StateProxyREA<S extends State<RIN, WIN>, RIN = S extends State<infer RT> ? RT : never, ROUT = RIN, WIN = S extends State<any, infer WT> ? WT : any, WOUT = WIN> = StateREA<ROUT, OptionNone, WOUT> & Owner$3<S, RIN, ROUT, WIN, WOUT>;
+interface OwnerWS$3<S, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> {
+    /**Sets the state that is being proxied, and updates subscribers with new value*/
+    set_state(state: S): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_read(transform: (val: Result<RIN, string>) => Result<ROUT, string>): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_write(transform: (val: WOUT) => WIN): void;
+    get state(): State<ROUT, WOUT, OptionNone>;
+    get read_only(): StateREA<ROUT, OptionNone, WOUT>;
+    get read_write(): StateREAWS<ROUT, WOUT, OptionNone>;
+}
+type StateProxyREAWS<S extends StateREAWS<RIN, WIN>, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> = StateREAWS<ROUT, WOUT, OptionNone> & OwnerWS$3<S, RIN, WIN, ROUT, WOUT>;
+interface OwnerWA$3<S, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> {
+    /**Sets the state that is being proxied, and updates subscribers with new value*/
+    set_state(state: S): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_read(transform: (val: Result<RIN, string>) => Result<ROUT, string>): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_write(transform: (val: WOUT) => WIN): void;
+    get state(): State<ROUT, WOUT, OptionNone>;
+    get read_only(): StateREA<ROUT, OptionNone, WOUT>;
+    get read_write(): StateREAWA<ROUT, WOUT, OptionNone>;
+}
+type StateProxyREAWA<S extends StateREAWA<RIN, WIN>, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> = StateREAWA<ROUT, WOUT, OptionNone> & OwnerWA$3<S, RIN, WIN, ROUT, WOUT>;
+
+interface Owner$2<S, RIN, ROUT, WIN, WOUT> {
+    /**Sets the state that is being proxied, and updates subscribers with new value*/
+    set_state(state: S): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_read(transform: (val: Result<RIN, string>) => Result<ROUT, string>): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_write(transform: (val: WOUT) => WIN): void;
+    get state(): State<ROUT, WOUT, OptionNone>;
+    get read_only(): StateRES<ROUT, OptionNone, WOUT>;
+}
+type StateProxyRES<S extends StateRES<RIN, any, WIN>, RIN = S extends State<infer RT> ? RT : never, ROUT = RIN, WIN = S extends State<any, infer WT> ? WT : any, WOUT = WIN> = StateRES<ROUT, OptionNone, WOUT> & Owner$2<S, RIN, ROUT, WIN, WOUT>;
+interface OwnerWS$2<S, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> {
+    /**Sets the state that is being proxied, and updates subscribers with new value*/
+    set_state(state: S): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_read(transform: (val: Result<RIN, string>) => Result<ROUT, string>): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_write(transform: (val: WOUT) => WIN): void;
+    get state(): State<ROUT, WOUT, OptionNone>;
+    get read_only(): StateRES<ROUT, OptionNone, WOUT>;
+    get read_write(): StateRESWS<ROUT, WOUT, OptionNone>;
+}
+type StateProxyRESWS<S extends StateRESWS<RIN, WIN>, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> = StateRESWS<ROUT, WOUT, OptionNone> & OwnerWS$2<S, RIN, WIN, ROUT, WOUT>;
+interface OwnerWA$2<S, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> {
+    /**Sets the state that is being proxied, and updates subscribers with new value*/
+    set_state(state: S): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_read(transform: (val: Result<RIN, string>) => Result<ROUT, string>): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_write(transform: (val: WOUT) => WIN): void;
+    get state(): State<ROUT, WOUT, OptionNone>;
+    get read_only(): StateRES<ROUT, OptionNone, WOUT>;
+    get read_write(): StateRESWA<ROUT, WOUT, OptionNone>;
+}
+type StateProxyRESWA<S extends StateRESWA<RIN, WIN>, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> = StateRESWA<ROUT, WOUT, OptionNone> & OwnerWA$2<S, RIN, WIN, ROUT, WOUT>;
+
+interface Owner$1<S extends State<any, any>, RIN, ROUT, WIN, WOUT> {
+    /**Sets the state that is being proxied, and updates subscribers with new value*/
+    set_state(state: S): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_read(transform: ROATransform<S, RIN, ROUT>): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_write(transform: (val: WOUT) => WIN): void;
+    get state(): State<ROUT, WOUT, OptionNone>;
+    get read_only(): StateROA<ROUT, OptionNone, WOUT>;
+}
+type ROATransform<S extends State<any, any>, IN, OUT> = (value: S extends StateROA<any> ? ResultOk<IN> : IN extends StateREA<any> ? Result<IN, string> : never) => ResultOk<OUT>;
+type StateProxyROA<S extends State<RIN, WIN>, RIN = S extends State<infer RT> ? RT : never, ROUT = RIN, WIN = S extends State<any, infer WT> ? WT : any, WOUT = WIN> = StateROA<ROUT, OptionNone, WOUT> & Owner$1<S, RIN, ROUT, WIN, WOUT>;
+interface OwnerWS$1<S, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> {
+    /**Sets the state that is being proxied, and updates subscribers with new value*/
+    set_state(state: S): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_read(transform: (val: Result<RIN, string>) => Result<ROUT, string>): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_write(transform: (val: WOUT) => WIN): void;
+    get state(): State<ROUT, WOUT, OptionNone>;
+    get read_only(): StateROA<ROUT, OptionNone, WOUT>;
+    get read_write(): StateROAWS<ROUT, WOUT, OptionNone>;
+}
+type StateProxyROAWS<S extends StateREAWS<RIN, WIN>, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> = StateROAWS<ROUT, WOUT, OptionNone> & OwnerWS$1<S, RIN, WIN, ROUT, WOUT>;
+interface OwnerWA$1<S, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> {
+    /**Sets the state that is being proxied, and updates subscribers with new value*/
+    set_state(state: S): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_read(transform: (val: Result<RIN, string>) => Result<ROUT, string>): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_write(transform: (val: WOUT) => WIN): void;
+    get state(): State<ROUT, WOUT, OptionNone>;
+    get read_only(): StateROA<ROUT, OptionNone, WOUT>;
+    get read_write(): StateROAWA<ROUT, WOUT, OptionNone>;
+}
+type StateProxyROAWA<S extends StateREAWA<RIN, WIN>, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> = StateROAWA<ROUT, WOUT, OptionNone> & OwnerWA$1<S, RIN, WIN, ROUT, WOUT>;
+
+interface Owner<S extends State<any, any>, RIN, ROUT, WIN, WOUT> {
+    /**Sets the state that is being proxied, and updates subscribers with new value*/
+    set_state(state: S): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_read(transform: ROSTransform<S, RIN, ROUT>): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_write(transform: (val: WOUT) => WIN): void;
+    get state(): State<ROUT, WOUT, OptionNone>;
+    get read_only(): StateROS<ROUT, OptionNone, WOUT>;
+}
+type ROSTransform<S extends State<any, any>, RIN, ROUT> = (value: S extends StateROS<any> ? ResultOk<RIN> : RIN extends StateRES<any> ? Result<RIN, string> : never) => ResultOk<ROUT>;
+type StateProxyROS<S extends StateRES<RIN, any, WIN>, RIN = S extends State<infer RT> ? RT : never, ROUT = RIN, WIN = S extends State<any, infer WT> ? WT : any, WOUT = WIN> = StateROS<ROUT, OptionNone, WOUT> & Owner<S, RIN, ROUT, WIN, WOUT>;
+interface OwnerWS<S, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> {
+    /**Sets the state that is being proxied, and updates subscribers with new value*/
+    set_state(state: S): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_read(transform: (val: Result<RIN, string>) => Result<ROUT, string>): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_write(transform: (val: WOUT) => WIN): void;
+    get state(): State<ROUT, WOUT, OptionNone>;
+    get read_only(): StateROS<ROUT, OptionNone, WOUT>;
+    get read_write(): StateROSWS<ROUT, WOUT, OptionNone>;
+}
+type StateProxyROSWS<S extends StateRESWS<RIN, WIN>, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> = StateROSWS<ROUT, WOUT, OptionNone> & OwnerWS<S, RIN, WIN, ROUT, WOUT>;
+interface OwnerWA<S, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> {
+    /**Sets the state that is being proxied, and updates subscribers with new value*/
+    set_state(state: S): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_read(transform: (val: Result<RIN, string>) => Result<ROUT, string>): void;
+    /**Changes the transform function of the proxy, and updates subscribers with new value*/
+    set_transform_write(transform: (val: WOUT) => WIN): void;
+    get state(): State<ROUT, WOUT, OptionNone>;
+    get read_only(): StateROS<ROUT, OptionNone, WOUT>;
+    get read_write(): StateROSWA<ROUT, WOUT, OptionNone>;
+}
+type StateProxyROSWA<S extends StateRESWA<RIN, WIN>, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> = StateROSWA<ROUT, WOUT, OptionNone> & OwnerWA<S, RIN, WIN, ROUT, WOUT>;
+
+declare const state: {
+    /**The state key is a symbol used to identify state objects
+     * To implement a custom state, set this key to true on the object */
+    STATE_KEY: symbol;
+    a: {
+        STATE_ARRAY_KEY: symbol;
+        apply_read: typeof apply_read;
+        ros: {
+            ok<AT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init?: AT[], helper?: StateHelper<{
+                type: "pop";
+            } | {
+                type: "shift";
+            } | {
+                type: "write";
+                items: readonly AT[];
+            } | {
+                type: "change";
+                index: number;
+                item: AT;
+            } | {
+                type: "push";
+                items: readonly AT[];
+            } | {
+                type: "unshift";
+                items: readonly AT[];
+            } | {
+                type: "delete";
+                item: AT;
+            } | {
+                type: "splice";
+                index: number;
+                delete_count: number;
+                items?: readonly AT[] | undefined;
+            }, REL>): StateArraySyncROS<AT, REL>;
+        };
+        ros_ws: {
+            ok<AT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init: AT[] | undefined, setter: StateSetREXWS<StateArrayRead<AT>, OwnerWS$7<AT, _chocbite_ts_lib_result.ResultOk<StateArrayRead<AT>>, REL>, {
+                type: "pop";
+            } | {
+                type: "shift";
+            } | {
+                type: "write";
+                items: readonly AT[];
+            } | {
+                type: "change";
+                index: number;
+                item: AT;
+            } | {
+                type: "push";
+                items: readonly AT[];
+            } | {
+                type: "unshift";
+                items: readonly AT[];
+            } | {
+                type: "delete";
+                item: AT;
+            } | {
+                type: "splice";
+                index: number;
+                delete_count: number;
+                items?: readonly AT[] | undefined;
+            }> | true, helper?: StateHelper<{
+                type: "pop";
+            } | {
+                type: "shift";
+            } | {
+                type: "write";
+                items: readonly AT[];
+            } | {
+                type: "change";
+                index: number;
+                item: AT;
+            } | {
+                type: "push";
+                items: readonly AT[];
+            } | {
+                type: "unshift";
+                items: readonly AT[];
+            } | {
+                type: "delete";
+                item: AT;
+            } | {
+                type: "splice";
+                index: number;
+                delete_count: number;
+                items?: readonly AT[] | undefined;
+            }, REL>): StateArraySyncROSWS<AT, REL>;
+        };
+        res: {
+            ok<AT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init?: AT[], helper?: StateHelper<{
+                type: "pop";
+            } | {
+                type: "shift";
+            } | {
+                type: "write";
+                items: readonly AT[];
+            } | {
+                type: "change";
+                index: number;
+                item: AT;
+            } | {
+                type: "push";
+                items: readonly AT[];
+            } | {
+                type: "unshift";
+                items: readonly AT[];
+            } | {
+                type: "delete";
+                item: AT;
+            } | {
+                type: "splice";
+                index: number;
+                delete_count: number;
+                items?: readonly AT[] | undefined;
+            }, REL>): StateArraySyncRES<AT, REL>;
+            err<AT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(error: string, helper?: StateHelper<{
+                type: "pop";
+            } | {
+                type: "shift";
+            } | {
+                type: "write";
+                items: readonly AT[];
+            } | {
+                type: "change";
+                index: number;
+                item: AT;
+            } | {
+                type: "push";
+                items: readonly AT[];
+            } | {
+                type: "unshift";
+                items: readonly AT[];
+            } | {
+                type: "delete";
+                item: AT;
+            } | {
+                type: "splice";
+                index: number;
+                delete_count: number;
+                items?: readonly AT[] | undefined;
+            }, REL>): StateArraySyncRES<AT, REL>;
+        };
+        res_ws: {
+            ok<AT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init: AT[] | undefined, setter: StateSetREXWS<StateArrayRead<AT>, OwnerWS$7<AT, _chocbite_ts_lib_result.Result<StateArrayRead<AT>, string>, REL>, {
+                type: "pop";
+            } | {
+                type: "shift";
+            } | {
+                type: "write";
+                items: readonly AT[];
+            } | {
+                type: "change";
+                index: number;
+                item: AT;
+            } | {
+                type: "push";
+                items: readonly AT[];
+            } | {
+                type: "unshift";
+                items: readonly AT[];
+            } | {
+                type: "delete";
+                item: AT;
+            } | {
+                type: "splice";
+                index: number;
+                delete_count: number;
+                items?: readonly AT[] | undefined;
+            }> | true, helper?: StateHelper<{
+                type: "pop";
+            } | {
+                type: "shift";
+            } | {
+                type: "write";
+                items: readonly AT[];
+            } | {
+                type: "change";
+                index: number;
+                item: AT;
+            } | {
+                type: "push";
+                items: readonly AT[];
+            } | {
+                type: "unshift";
+                items: readonly AT[];
+            } | {
+                type: "delete";
+                item: AT;
+            } | {
+                type: "splice";
+                index: number;
+                delete_count: number;
+                items?: readonly AT[] | undefined;
+            }, REL>): StateArraySyncRESWS<AT, REL>;
+            err<AT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(error: string, setter: StateSetREXWS<StateArrayRead<AT>, OwnerWS$7<AT, _chocbite_ts_lib_result.Result<StateArrayRead<AT>, string>, REL>, {
+                type: "pop";
+            } | {
+                type: "shift";
+            } | {
+                type: "write";
+                items: readonly AT[];
+            } | {
+                type: "change";
+                index: number;
+                item: AT;
+            } | {
+                type: "push";
+                items: readonly AT[];
+            } | {
+                type: "unshift";
+                items: readonly AT[];
+            } | {
+                type: "delete";
+                item: AT;
+            } | {
+                type: "splice";
+                index: number;
+                delete_count: number;
+                items?: readonly AT[] | undefined;
+            }> | true, helper?: StateHelper<{
+                type: "pop";
+            } | {
+                type: "shift";
+            } | {
+                type: "write";
+                items: readonly AT[];
+            } | {
+                type: "change";
+                index: number;
+                item: AT;
+            } | {
+                type: "push";
+                items: readonly AT[];
+            } | {
+                type: "unshift";
+                items: readonly AT[];
+            } | {
+                type: "delete";
+                item: AT;
+            } | {
+                type: "splice";
+                index: number;
+                delete_count: number;
+                items?: readonly AT[] | undefined;
+            }, REL>): StateArraySyncRESWS<AT, REL>;
+        };
+        is(s: unknown): s is StateArray<any, any>;
+        write<T>(items: T[]): StateArrayWrite<T>;
+        index<T>(index: number, value: T): StateArrayWrite<T>;
+        push<T>(...items: T[]): StateArrayWrite<T>;
+        pop<T>(): StateArrayWrite<T>;
+        shift<T>(): StateArrayWrite<T>;
+        unshift<T>(...items: T[]): StateArrayWrite<T>;
+        splice<T>(start: number, delete_count?: number, ...items: T[]): StateArrayWrite<T>;
+        pluck<T>(index: number): StateArrayWrite<T>;
+        insert<T>(index: number, ...items: T[]): StateArrayWrite<T>;
+    };
+    /**Collected states, collects values from multiple states and reduces it to one */
+    c: {
+        rea: {
+            from<RT, IN extends State<any>[], WT = any>(transform: ((values: StateCollectedTransVal<IN>) => _chocbite_ts_lib_result.Result<RT, string>) | false, ...states: IN): StateCollectedREA<RT, IN, WT>;
+            class: typeof REA;
+        };
+        res: {
+            from<RT, IN extends StateRES<any>[], WT = any>(transform: ((values: StateCollectedTransVal<IN>) => _chocbite_ts_lib_result.Result<RT, string>) | false, ...states: IN): StateCollectedRES<RT, IN, WT>;
+            class: typeof RES;
+        };
+        roa: {
+            from<RT, IN extends [State<any>, ...State<any>[]], WT = any>(transform: ((values: StateCollectedTransVal<IN>) => _chocbite_ts_lib_result.ResultOk<RT>) | false, ...states: IN): StateCollectedROA<RT, IN, WT>;
+            class: typeof ROA;
+        };
+        ros: {
+            from<RT, IN extends [StateRES<any>, ...StateRES<any>[]], WT = any>(transform: ((values: StateCollectedTransVal<IN>) => _chocbite_ts_lib_result.ResultOk<RT>) | false, ...states: IN): StateCollectedROS<RT, IN, WT>;
+            class: typeof ROS;
+        };
+        num: {
+            sum: {
+                rea<S extends State<number>[]>(...states: S): StateCollectedREA<number, S>;
+                roa<S extends [StateROA<number>, ...StateROA<number>[]]>(...states: S): StateCollectedROA<number, S>;
+                res<S extends StateRES<number>[]>(...states: S): StateCollectedRES<number, S>;
+                ros<S extends [StateROS<number>, ...StateROS<number>[]]>(...states: S): StateCollectedROS<number, S>;
+            };
+            percentage: {
+                rea<S extends State<number>, T extends State<number>>(st1: S, st2: T): StateCollectedREA<number, [S, T]>;
+                roa<S extends StateROA<number>, T extends StateROA<number>>(st1: S, st2: T): StateCollectedROA<number, [S, T]>;
+                res<S extends StateRES<number>, T extends StateRES<number>>(st1: S, st2: T): StateCollectedRES<number, [S, T]>;
+                ros<S extends StateROS<number>, T extends StateROS<number>>(st1: S, st2: T): StateCollectedROS<number, [S, T]>;
+            };
+        };
+    };
+    d: {
+        roa: {
+            ok<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(init?: () => PromiseLike<RT>, helper?: StateHelper<WT, REL>): StateDelayedROA<RT, REL, WT>;
+            result<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(init?: () => PromiseLike<_chocbite_ts_lib_result.ResultOk<RT>>, helper?: StateHelper<WT, REL>): StateDelayedROA<RT, REL, WT>;
+        };
+        roa_ws: {
+            ok<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init?: () => PromiseLike<RT>, setter?: ((value: WT, state: OwnerWS$4<RT, _chocbite_ts_lib_result.ResultOk<RT>, WT, REL>, old?: _chocbite_ts_lib_result.ResultOk<RT> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>): StateDelayedROAWS<RT, WT, REL>;
+            result<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init?: () => PromiseLike<_chocbite_ts_lib_result.ResultOk<RT>>, setter?: ((value: WT, state: OwnerWS$4<RT, _chocbite_ts_lib_result.ResultOk<RT>, WT, REL>, old?: _chocbite_ts_lib_result.ResultOk<RT> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>): StateDelayedROAWS<RT, WT, REL>;
+        };
+        roa_wa: {
+            ok<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init?: () => PromiseLike<RT>, setter?: ((value: WT, state: OwnerWA$4<RT, _chocbite_ts_lib_result.ResultOk<RT>, WT, REL>, old?: _chocbite_ts_lib_result.ResultOk<RT> | undefined) => Promise<_chocbite_ts_lib_result.Result<void, string>>) | true, helper?: StateHelper<WT, REL>): StateDelayedROAWA<RT, WT, REL>;
+            result<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init?: () => PromiseLike<_chocbite_ts_lib_result.ResultOk<RT>>, setter?: ((value: WT, state: OwnerWA$4<RT, _chocbite_ts_lib_result.ResultOk<RT>, WT, REL>, old?: _chocbite_ts_lib_result.ResultOk<RT> | undefined) => Promise<_chocbite_ts_lib_result.Result<void, string>>) | true, helper?: StateHelper<WT, REL>): StateDelayedROAWA<RT, WT, REL>;
+        };
+        rea: {
+            ok<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(init?: () => PromiseLike<RT>, helper?: StateHelper<WT, REL>): StateDelayedREA<RT, REL, WT>;
+            err<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(init?: () => PromiseLike<string>, helper?: StateHelper<WT, REL>): StateDelayedREA<RT, REL, WT>;
+            result<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(init?: () => PromiseLike<_chocbite_ts_lib_result.Result<RT, string>>, helper?: StateHelper<WT, REL>): StateDelayedREA<RT, REL, WT>;
+        };
+        rea_ws: {
+            ok<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init?: () => PromiseLike<RT>, setter?: ((value: WT, state: OwnerWS$4<RT, _chocbite_ts_lib_result.Result<RT, string>, WT, REL>, old?: _chocbite_ts_lib_result.Result<RT, string> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>): StateDelayedREAWS<RT, WT, REL>;
+            err<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init?: () => PromiseLike<string>, setter?: ((value: WT, state: OwnerWS$4<RT, _chocbite_ts_lib_result.Result<RT, string>, WT, REL>, old?: _chocbite_ts_lib_result.Result<RT, string> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>): StateDelayedREAWS<RT, WT, REL>;
+            result<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init?: () => PromiseLike<_chocbite_ts_lib_result.Result<RT, string>>, setter?: ((value: WT, state: OwnerWS$4<RT, _chocbite_ts_lib_result.Result<RT, string>, WT, REL>, old?: _chocbite_ts_lib_result.Result<RT, string> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>): StateDelayedREAWS<RT, WT, REL>;
+        };
+        rea_wa: {
+            ok<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init?: () => PromiseLike<RT>, setter?: ((value: WT, state: OwnerWA$4<RT, _chocbite_ts_lib_result.Result<RT, string>, WT, REL>, old?: _chocbite_ts_lib_result.Result<RT, string> | undefined) => Promise<_chocbite_ts_lib_result.Result<void, string>>) | true, helper?: StateHelper<WT, REL>): StateDelayedREAWA<RT, WT, REL>;
+            err<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init?: () => PromiseLike<string>, setter?: ((value: WT, state: OwnerWA$4<RT, _chocbite_ts_lib_result.Result<RT, string>, WT, REL>, old?: _chocbite_ts_lib_result.Result<RT, string> | undefined) => Promise<_chocbite_ts_lib_result.Result<void, string>>) | true, helper?: StateHelper<WT, REL>): StateDelayedREAWA<RT, WT, REL>;
+            result<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init?: () => PromiseLike<_chocbite_ts_lib_result.Result<RT, string>>, setter?: ((value: WT, state: OwnerWA$4<RT, _chocbite_ts_lib_result.Result<RT, string>, WT, REL>, old?: _chocbite_ts_lib_result.Result<RT, string> | undefined) => Promise<_chocbite_ts_lib_result.Result<void, string>>) | true, helper?: StateHelper<WT, REL>): StateDelayedREAWA<RT, WT, REL>;
+        };
+    };
+    h: {
+        is: {
+            rea(s: any): s is StateREA<any>;
+            roa(s: any): s is StateROA<any>;
+            res(s: any): s is StateRES<any>;
+            ros(s: any): s is StateROS<any>;
+            rea_wa(s: any): s is StateREAWA<any>;
+            rea_ws(s: any): s is StateREAWS<any>;
+            roa_wa(s: any): s is StateROAWA<any>;
+            roa_ws(s: any): s is StateROAWS<any>;
+            res_wa(s: any): s is StateRESWA<any>;
+            res_ws(s: any): s is StateRESWS<any>;
+            ros_wa(s: any): s is StateROSWA<any>;
+            ros_ws(s: any): s is StateROSWS<any>;
+        };
+        nums: {
+            helper(min?: number, max?: number, unit?: string, decimals?: number, step?: number, start?: number): StateNumberHelper;
+        };
+        strings: {
+            helper(max_length?: number, max_length_bytes?: number): StateStringHelper;
+        };
+        enums: {
+            helper<L extends {
+                [x: string]: {
+                    name: string;
+                    description?: string;
+                    icon?: _chocbite_ts_lib_svg.SVGFunc;
+                };
+            }, K extends PropertyKey = keyof L, R extends StateRelated = StateEnumRelated<L>>(list: L): StateEnumHelper<L, K, R>;
+            list<K extends PropertyKey>(list: { [P in K]: {
+                name: string;
+                description?: string;
+                icon?: _chocbite_ts_lib_svg.SVGFunc;
+            }; }): typeof list;
+        };
+        await_value: <T>(value: T, state: State<T>, timeout?: number) => Promise<boolean>;
+        compare: (state1: State<any>, state2: State<any>) => Promise<boolean>;
+        compare_sync: (state1: StateRES<any>, state2: StateRES<any>) => boolean;
+    };
+    l: {
+        ros: {
+            ok<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(init: () => RT, helper?: StateHelper<WT, REL>): StateLazyROS<RT, REL, WT>;
+            result<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(init: () => _chocbite_ts_lib_result.ResultOk<RT>, helper?: StateHelper<WT, REL>): StateLazyROS<RT, REL, WT>;
+        };
+        ros_ws: {
+            ok<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init: () => RT, setter?: ((value: WT, state: OwnerWS$5<RT, _chocbite_ts_lib_result.ResultOk<RT>, WT, REL>, old?: _chocbite_ts_lib_result.ResultOk<RT> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>): StateLazyROSWS<RT, WT, REL>;
+            result<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init: () => _chocbite_ts_lib_result.ResultOk<RT>, setter?: ((value: WT, state: OwnerWS$5<RT, _chocbite_ts_lib_result.ResultOk<RT>, WT, REL>, old?: _chocbite_ts_lib_result.ResultOk<RT> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>): StateLazyROSWS<RT, WT, REL>;
+        };
+        res: {
+            ok<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(init: () => RT, helper?: StateHelper<WT, REL>): StateLazyRES<RT, REL, WT>;
+            err<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(init: () => string, helper?: StateHelper<WT, REL>): StateLazyRES<RT, REL, WT>;
+            result<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(init: () => _chocbite_ts_lib_result.Result<RT, string>, helper?: StateHelper<WT, REL>): StateLazyRES<RT, REL, WT>;
+        };
+        res_ws: {
+            ok<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init: () => RT, setter?: ((value: WT, state: OwnerWS$5<RT, _chocbite_ts_lib_result.Result<RT, string>, WT, REL>, old?: _chocbite_ts_lib_result.Result<RT, string> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>): StateLazyRESWS<RT, WT, REL>;
+            err<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init: () => string, setter?: ((value: WT, state: OwnerWS$5<RT, _chocbite_ts_lib_result.Result<RT, string>, WT, REL>, old?: _chocbite_ts_lib_result.Result<RT, string> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>): StateLazyRESWS<RT, WT, REL>;
+            result<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init: () => _chocbite_ts_lib_result.Result<RT, string>, setter?: ((value: WT, state: OwnerWS$5<RT, _chocbite_ts_lib_result.Result<RT, string>, WT, REL>, old?: _chocbite_ts_lib_result.Result<RT, string> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>): StateLazyRESWS<RT, WT, REL>;
+        };
+    };
+    p: {
+        ros: {
+            <S extends StateROS<RIN, any, WIN>, RIN = S extends State<infer RT> ? RT : never, ROUT = RIN, WIN = S extends State<any, infer RT_1> ? RT_1 : any, WOUT = WIN>(state: StateROS<RIN, any, WIN>, transform?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.ResultOk<ROUT>): StateProxyROS<S, RIN, ROUT, WIN, WOUT>;
+            <S extends StateRES<RIN, any, WIN>, RIN = S extends State<infer RT> ? RT : never, ROUT = RIN, WIN = S extends State<any, infer RT_1> ? RT_1 : any, WOUT = WIN>(state: StateRES<RIN, any, WIN>, transform: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.ResultOk<ROUT>): StateProxyROS<S, RIN, ROUT, WIN, WOUT>;
+        };
+        ros_ws: {
+            <S extends StateROSWS<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateROSWS<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.ResultOk<ROUT>, transform_write?: (value: WOUT) => WIN): StateProxyROSWS<S, RIN, WIN, ROUT, WOUT>;
+            <S extends StateRESWS<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateRESWS<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.ResultOk<ROUT>, transform_write?: (value: WOUT) => WIN): StateProxyROSWS<S, RIN, WIN, ROUT, WOUT>;
+        };
+        ros_wa: {
+            <S extends StateROSWA<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateROSWA<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.ResultOk<ROUT>, transform_write?: (value: WOUT) => WIN): StateProxyROSWA<S, RIN, WIN, ROUT, WOUT>;
+            <S extends StateRESWA<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateRESWA<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.ResultOk<ROUT>, transform_write?: (value: WOUT) => WIN): StateProxyROSWA<S, RIN, WIN, ROUT, WOUT>;
+        };
+        roa: {
+            <S extends StateROA<RIN, any, WIN>, RIN = S extends State<infer RT> ? RT : never, ROUT = RIN, WIN = S extends State<any, infer RT_1> ? RT_1 : any, WOUT = WIN>(state: StateROA<RIN, any, WIN>, transform?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.ResultOk<ROUT>): StateProxyROA<S, RIN, ROUT, WIN, WOUT>;
+            <S extends StateREA<RIN, any, WIN>, RIN = S extends State<infer RT> ? RT : never, ROUT = RIN, WIN = S extends State<any, infer RT_1> ? RT_1 : any, WOUT = WIN>(state: StateREA<RIN, any, WIN>, transform: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.ResultOk<ROUT>): StateProxyROA<S, RIN, ROUT, WIN, WOUT>;
+        };
+        roa_ws: {
+            <S extends StateROAWS<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateROAWS<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.ResultOk<ROUT>, transform_write?: (value: WOUT) => WIN): StateProxyROAWS<S, RIN, WIN, ROUT, WOUT>;
+            <S extends StateREAWS<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateREAWS<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.ResultOk<ROUT>, transform_write?: (value: WOUT) => WIN): StateProxyROAWS<S, RIN, WIN, ROUT, WOUT>;
+        };
+        roa_wa: {
+            <S extends StateROAWA<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateROAWA<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.ResultOk<ROUT>, transform_write?: (value: WOUT) => WIN): StateProxyROAWA<S, RIN, WIN, ROUT, WOUT>;
+            <S extends StateREAWA<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateREAWA<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.ResultOk<ROUT>, transform_write?: (value: WOUT) => WIN): StateProxyROAWA<S, RIN, WIN, ROUT, WOUT>;
+        };
+        res: {
+            <S extends StateROS<RIN, any, WIN>, RIN = S extends State<infer RT> ? RT : never, ROUT = RIN, WIN = S extends State<any, infer WT> ? WT : any, WOUT = WIN>(state: StateROS<RIN, any, WIN>, transform?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.Result<ROUT, string>): StateProxyRES<S, RIN, ROUT, WIN, WOUT>;
+            <S extends StateRES<RIN, any, WIN>, RIN = S extends State<infer RT> ? RT : never, ROUT = RIN, WIN = S extends State<any, infer RT_1> ? RT_1 : any, WOUT = WIN>(state: StateRES<RIN, any, WIN>, transform?: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.Result<ROUT, string>): StateProxyRES<S, RIN, ROUT, WIN, WOUT>;
+        };
+        res_ws: {
+            <S extends StateROSWS<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateROSWS<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.Result<ROUT, string>, transform_write?: (value: WOUT) => WIN): StateProxyRESWS<S, RIN, WIN, ROUT, WOUT>;
+            <S extends StateRESWS<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateRESWS<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.Result<ROUT, string>, transform_write?: (value: WOUT) => WIN): StateProxyRESWS<S, RIN, WIN, ROUT, WOUT>;
+        };
+        res_wa: {
+            <S extends StateROSWA<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateROSWA<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.Result<ROUT, string>, transform_write?: (value: WOUT) => WIN): StateProxyRESWA<S, RIN, WIN, ROUT, WOUT>;
+            <S extends StateRESWA<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateRESWA<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.Result<ROUT, string>, transform_write?: (value: WOUT) => WIN): StateProxyRESWA<S, RIN, WIN, ROUT, WOUT>;
+        };
+        rea: {
+            <S extends StateROA<RIN, any, WIN>, RIN = S extends State<infer RT> ? RT : never, ROUT = RIN, WIN = S extends State<any, infer RT_1> ? RT_1 : any, WOUT = WIN>(state: StateROA<RIN, any, WIN>, transform?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.Result<ROUT, string>): StateProxyREA<S, RIN, ROUT, WIN, WOUT>;
+            <S extends StateREA<RIN, any, WIN>, RIN = S extends State<infer RT> ? RT : never, ROUT = RIN, WIN = S extends State<any, infer RT_1> ? RT_1 : any, WOUT = WIN>(state: StateREA<RIN, any, WIN>, transform?: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.Result<ROUT, string>): StateProxyREA<S, RIN, ROUT, WIN, WOUT>;
+        };
+        rea_ws: {
+            <S extends StateROAWS<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateROAWS<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.Result<ROUT, string>, transform_write?: (value: WOUT) => WIN): StateProxyREAWS<S, RIN, WIN, ROUT, WOUT>;
+            <S extends StateREAWS<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateREAWS<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.Result<ROUT, string>, transform_write?: (value: WOUT) => WIN): StateProxyREAWS<S, RIN, WIN, ROUT, WOUT>;
+        };
+        rea_wa: {
+            <S extends StateROAWA<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateROAWA<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.Result<ROUT, string>, transform_write?: (value: WOUT) => WIN): StateProxyREAWA<S, RIN, WIN, ROUT, WOUT>;
+            <S extends StateREAWA<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateREAWA<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.Result<ROUT, string>, transform_write?: (value: WOUT) => WIN): StateProxyREAWA<S, RIN, WIN, ROUT, WOUT>;
+        };
+    };
+    r: {
+        roa: {
+            from<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(once: (state: Owner$a<RT, WT, REL>) => void, setup: (state: Owner$a<RT, WT, REL>) => void, teardown: (state: Owner$a<RT, WT, REL>) => void, times?: {
+                timeout?: number;
+                debounce?: number;
+                validity?: number | true;
+                retention?: number;
+            }, helper?: StateHelper<WT, REL>): StateResourceFuncROA<RT, REL, WT>;
+            class: typeof StateResourceROA;
+        };
+        rea: {
+            from<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(once: (state: Owner$b<RT, WT, REL>) => void, setup: (state: Owner$b<RT, WT, REL>) => void, teardown: (state: Owner$b<RT, WT, REL>) => void, times?: {
+                timeout?: number;
+                debounce?: number;
+                validity?: number | true;
+                retention?: number;
+            }, helper?: StateHelper<WT, REL>): StateResourceFuncREA<RT, REL, WT>;
+            class: typeof StateResourceREA;
+        };
+        rea_wa: {
+            from<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = RT>(once: (state: OwnerWA$5<RT, WT, REL>) => void, setup: (state: OwnerWA$5<RT, WT, REL>) => void, teardown: () => void, write_action?: (value: WT, state: OwnerWA$5<RT, WT, REL>) => Promise<_chocbite_ts_lib_result.Result<void, string>>, times?: {
+                timeout?: number;
+                debounce?: number;
+                validity?: number | true;
+                retention?: number;
+                write_debounce?: number;
+            }, helper?: StateHelper<WT, REL>): StateResourceFuncREAWA<RT, REL, WT>;
+            class: typeof StateResourceREAWA;
+        };
+    };
+    s: {
+        ros: {
+            ok<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(this: void, init: RT, helper?: StateHelper<WT, REL>): StateSyncROS<RT, REL, WT>;
+            result<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(init: _chocbite_ts_lib_result.ResultOk<RT>, helper?: StateHelper<WT, REL>): StateSyncROS<RT, REL, WT>;
+        };
+        ros_ws: {
+            ok<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(this: void, init: RT, setter?: ((value: WT, state: OwnerWS$6<RT, _chocbite_ts_lib_result.ResultOk<RT>, WT, REL>, old?: _chocbite_ts_lib_result.ResultOk<RT> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>): StateSyncROSWS<RT, WT, REL>;
+            result<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init: _chocbite_ts_lib_result.ResultOk<RT>, setter?: ((value: WT, state: OwnerWS$6<RT, _chocbite_ts_lib_result.ResultOk<RT>, WT, REL>, old?: _chocbite_ts_lib_result.ResultOk<RT> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>): StateSyncROSWS<RT, WT, REL>;
+        };
+        res: {
+            ok<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(this: void, init: RT, helper?: StateHelper<WT, REL>): StateSyncRES<RT, REL, WT>;
+            err<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(this: void, init: string, helper?: StateHelper<WT, REL>): StateSyncRES<RT, REL, WT>;
+            result<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(init: _chocbite_ts_lib_result.Result<RT, string>, helper?: StateHelper<WT, REL>): StateSyncRES<RT, REL, WT>;
+        };
+        res_ws: {
+            ok<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(this: void, init: RT, setter?: ((value: WT, state: OwnerWS$6<RT, _chocbite_ts_lib_result.Result<RT, string>, WT, REL>, old?: _chocbite_ts_lib_result.Result<RT, string> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>): StateSyncRESWS<RT, WT, REL>;
+            err<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(this: void, init: string, setter?: ((value: WT, state: OwnerWS$6<RT, _chocbite_ts_lib_result.Result<RT, string>, WT, REL>, old?: _chocbite_ts_lib_result.Result<RT, string> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>): StateSyncRESWS<RT, WT, REL>;
+            result<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init: _chocbite_ts_lib_result.Result<RT, string>, setter?: ((value: WT, state: OwnerWS$6<RT, _chocbite_ts_lib_result.Result<RT, string>, WT, REL>, old?: _chocbite_ts_lib_result.Result<RT, string> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>): StateSyncRESWS<RT, WT, REL>;
+        };
+    };
+    /**Returns true if the given object promises to be a state */
+    is(s: unknown): s is State<any, any>;
+    /**Utility base class for state, with basic state functionality */
+    class: typeof StateBase;
+    ok: <RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(this: void, init: RT, helper?: StateHelper<WT, REL>) => StateSyncROS<RT, REL, WT>;
+    err: <RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(this: void, init: string, helper?: StateHelper<WT, REL>) => StateSyncRES<RT, REL, WT>;
+    from: <RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = any>(this: void, init: RT, helper?: StateHelper<WT, REL>) => StateSyncRES<RT, REL, WT>;
+    ok_ws: <RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(this: void, init: RT, setter?: ((value: WT, state: OwnerWS$6<RT, _chocbite_ts_lib_result.ResultOk<RT>, WT, REL>, old?: _chocbite_ts_lib_result.ResultOk<RT> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>) => StateSyncROSWS<RT, WT, REL>;
+    err_ws: <RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(this: void, init: string, setter?: ((value: WT, state: OwnerWS$6<RT, _chocbite_ts_lib_result.Result<RT, string>, WT, REL>, old?: _chocbite_ts_lib_result.Result<RT, string> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>) => StateSyncRESWS<RT, WT, REL>;
+    from_ws: <RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(this: void, init: RT, setter?: ((value: WT, state: OwnerWS$6<RT, _chocbite_ts_lib_result.Result<RT, string>, WT, REL>, old?: _chocbite_ts_lib_result.Result<RT, string> | undefined) => _chocbite_ts_lib_result.Result<void, string>) | true, helper?: StateHelper<WT, REL>) => StateSyncRESWS<RT, WT, REL>;
+};
+
+export { type State, type StateArray, type StateArrayREA, type StateArrayREAWA, type StateArrayREAWS, type StateArrayRES, type StateArrayRESWA, type StateArrayRESWS, type StateArrayROA, type StateArrayROAWA, type StateArrayROAWS, type StateArrayROS, type StateArrayROSWA, type StateArrayROSWS, type StateArrayRead, StateArrayReadType, type StateArraySyncRES, type StateArraySyncRESWS, type StateArraySyncROS, type StateArraySyncROSWS, type StateArrayWrite, type StateCollectedREA, type StateCollectedRES, type StateCollectedROA, type StateCollectedROS, type StateDelayedREA, type StateDelayedREAWA, type StateDelayedREAWS, type StateDelayedROA, type StateDelayedROAWA, type StateDelayedROAWS, StateEnumHelper, type StateEnumRelated, type StateInferResult, type StateInferSub, type StateInferType, type StateLazyRES, type StateLazyRESWS, type StateLazyROS, type StateLazyROSWS, StateNumberHelper, type StateNumberRelated, type StateProxyREA, type StateProxyREAWA, type StateProxyREAWS, type StateProxyRES, type StateProxyRESWA, type StateProxyRESWS, type StateProxyROA, type StateProxyROAWA, type StateProxyROAWS, type StateProxyROS, type StateProxyROSWA, type StateProxyROSWS, type StateREA, type StateREAWA, type StateREAWS, type StateRES, type StateRESWA, type StateRESWS, type StateROA, type StateROAWA, type StateROAWS, type StateROS, type StateROSWA, type StateROSWS, type StateResourceFuncREA, type StateResourceFuncREAWA, type StateResourceFuncROA, StateResourceREA, StateResourceREAWA, StateResourceROA, StateStringHelper, type StateStringRelated, type StateSub, type StateSyncRES, type StateSyncRESWS, type StateSyncROS, type StateSyncROSWS, state };