@chocbite/ts-lib-state 1.0.2 → 1.1.0

package/dist/index.d.ts

@@ -44,7 +44,7 @@ interface StateArrayRead<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>;
+type ArraySetter<AT, RRT extends Result<SAR<AT>, string>, REL extends Option<StateRelated>> = (value: SAW<AT>, state: OwnerWS<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;
@@ -62,30 +62,30 @@ interface Owner$d<AT, RRT extends Result<SAR<AT>, string>, REL extends Option<St
     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> {
+interface OwnerWS<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>;
+    readonly read_write?: StateArrayROSW<AT, REL>;
 };
-type StateArraySyncROSWS<AT, REL extends Option<StateRelated> = Option<{}>> = StateROSWS<SAR<AT>, SAW<AT>, REL> & OwnerWS$7<AT, ResultOk<SAR<AT>>, REL> & {
+type StateArraySyncROSWS<AT, REL extends Option<StateRelated> = Option<{}>> = StateROSW<SAR<AT>, SAW<AT>, REL> & OwnerWS<AT, ResultOk<SAR<AT>>, REL> & {
     readonly state: StateArray<AT, REL>;
     readonly read_only: StateArrayROS<AT, REL>;
-    readonly read_write: StateArrayROSWS<AT, REL>;
+    readonly read_write: StateArrayROSW<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>;
+    readonly read_write?: StateArrayRESW<AT, REL>;
 };
-type StateArraySyncRESWS<AT, REL extends Option<StateRelated> = Option<{}>> = StateRESWS<SAR<AT>, SAW<AT>, REL> & OwnerWS$7<AT, ResultOk<SAR<AT>>, REL> & {
+type StateArraySyncRESWS<AT, REL extends Option<StateRelated> = Option<{}>> = StateRESW<SAR<AT>, SAW<AT>, REL> & OwnerWS<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>;
+    readonly read_write: StateArrayRESW<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[];
@@ -97,26 +97,19 @@ type StateInferResult<S extends State<any>> = S extends StateROA<infer RT> ? Res
 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 StateRelated = {};
 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>;
+    /**Is state guarenteed sync*/
+    readonly rsync: boolean;
     /**Gets the current value of the state if state is sync*/
     get?(): RRT;
+    /**Is state guarenteed OK*/
+    readonly rok: boolean;
     /**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
@@ -130,195 +123,194 @@ interface StateBase$1<RT, WT, REL extends Option<StateRelated>, RRT extends Resu
     in_use(): this | undefined;
     /**Returns if the state has a subscriber */
     has(subscriber: StateSub<RRT>): this | undefined;
-    /**Returns if the state has a subscriber */
+    /**Returns the amount of subscribers the state has */
     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>;
+    limit?(value: WT): Promise<Result<WT, string>>;
     /**Checks if the value is valid and returns reason for invalidity */
-    check?(value: WT): Result<WT, string>;
+    check?(value: WT): Promise<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 rok: false;
     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>;
+    readonly rok: true;
     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>> {
+interface REAW<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>;
+    limit(value: WT): Promise<Result<WT, string>>;
+    check(value: WT): Promise<Result<WT, string>>;
 }
-interface ROAWA<RT, WT, REL extends Option<StateRelated>> extends StateBase$1<RT, WT, REL, ResultOk<RT>> {
+interface ROAW<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>;
+    limit(value: WT): Promise<Result<WT, string>>;
+    check(value: WT): Promise<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>> {
+interface RESW<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>;
+    limit(value: WT): Promise<Result<WT, string>>;
+    check(value: WT): Promise<Result<WT, string>>;
 }
-interface ROSWA<RT, WT, REL extends Option<StateRelated>> extends StateBase$1<RT, WT, REL, ResultOk<RT>> {
+interface ROSW<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>;
+    limit(value: WT): Promise<Result<WT, string>>;
+    check(value: WT): Promise<Result<WT, 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 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> | StateREAW<RT, WT, REL> | StateROAW<RT, WT, REL> | StateRESW<RT, WT, REL> | StateROSW<RT, WT, REL>;
+type StateREA<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = REA$1<RT, REL, WT> | StateREAW<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> | StateROAW<RT, WT, REL> | StateROS<RT, REL, WT>;
+type StateRES<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = RES$1<RT, REL, WT> | StateRESW<RT, WT, REL> | StateROS<RT, REL, WT>;
+type StateROS<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = ROS$1<RT, REL, WT> | StateROSW<RT, WT, REL>;
+type StateREAW<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = REAW<RT, WT, REL> | StateROAW<RT, WT, REL> | StateROSW<RT, WT, REL> | StateRESW<RT, WT, REL>;
+type StateROAW<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = ROAW<RT, WT, REL> | StateROSW<RT, WT, REL>;
+type StateRESW<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = RESW<RT, WT, REL> | StateROSW<RT, WT, REL>;
+type StateROSW<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = ROSW<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 StateArrayREAW<AT, REL extends Option<StateRelated> = Option<{}>> = StateREAW<StateArrayRead<AT>, StateArrayWrite<AT>, REL>;
+type StateArrayROAW<AT, REL extends Option<StateRelated> = Option<{}>> = StateROAW<StateArrayRead<AT>, StateArrayWrite<AT>, REL>;
+type StateArrayRESW<AT, REL extends Option<StateRelated> = Option<{}>> = StateRESW<StateArrayRead<AT>, StateArrayWrite<AT>, REL>;
+type StateArrayROSW<AT, REL extends Option<StateRelated> = Option<{}>> = StateROSW<StateArrayRead<AT>, StateArrayWrite<AT>, REL>;
+
+interface StateRelatedBase extends StateRelated {
+    writable?: State<boolean>;
+}
+declare abstract class StateHelper<WT, REL extends Option<StateRelatedBase>> implements StateRelatedBase {
+    readonly writable?: State<boolean>;
+    constructor(writable?: State<boolean>);
+    abstract related(): REL;
+    abstract limit(value: WT): Promise<Result<WT, string>>;
+    abstract check(value: WT): Promise<Result<WT, string>>;
+}
+interface StateNumberRelated extends StateRelatedBase {
+    min?: State<number>;
+    max?: State<number>;
+    unit?: State<string>;
+    decimals?: State<number>;
+    step?: State<number>;
+    start?: State<number>;
+}
+declare class StateNumberHelper extends StateHelper<number, OptionSome<StateNumberRelated>> implements StateNumberRelated {
+    readonly min?: State<number>;
+    readonly max?: State<number>;
+    readonly unit?: State<string>;
+    readonly decimals?: State<number>;
+    readonly step?: State<number>;
+    readonly start?: State<number>;
+    constructor(min?: State<number>, max?: State<number>, unit?: State<string>, decimals?: State<number>, step?: State<number>, start?: State<number>, writable?: State<boolean>);
+    limit(value: number): Promise<Result<number, string>>;
+    check(value: number): Promise<Result<number, string>>;
+    related(): OptionSome<StateNumberRelated>;
+}
+interface StateStringRelated extends StateRelatedBase {
+    max_length?: State<number>;
+    max_length_bytes?: State<number>;
+}
+declare class StateStringHelper extends StateHelper<string, OptionSome<StateStringRelated>> implements StateStringRelated {
+    max_length?: State<number>;
+    max_length_bytes?: State<number>;
+    constructor(max_length?: State<number>, max_length_bytes?: State<number>, writable?: State<boolean>);
+    limit(value: string): Promise<Result<string, string>>;
+    check(value: string): Promise<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 StateRelatedBase {
+    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 StateRelatedBase = StateEnumRelated<L>> extends StateHelper<K, OptionSome<R>> {
+    readonly list: State<L>;
+    constructor(list: State<L>, writable?: State<boolean>);
+    map<K extends keyof L, R>(func: (key: K, val: EnumHelperEntry) => R): Promise<R[]>;
+    limit(value: K): Promise<Result<K, string>>;
+    check(value: K): Promise<Result<K, string>>;
+    related(): OptionSome<R>;
+}
 
-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>;
+type SyncSetter<RT, RRT extends Result<RT, string>, REL extends Option<StateRelated>, WT = RT> = (value: WT, state: OwnerWrite$6<RT, RRT, WT, REL>, old?: RRT) => Promise<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> {
+interface OwnerWrite$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>;
+    readonly read_write?: StateROSW<RT, WT, REL>;
 };
-type StateSyncROSWS<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateROSWS<RT, WT, REL> & OwnerWS$6<RT, ResultOk<RT>, WT, REL> & {
+type StateSyncROSW<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateROSW<RT, WT, REL> & OwnerWrite$6<RT, ResultOk<RT>, WT, REL> & {
     readonly read_only: StateROS<RT, REL, WT>;
-    readonly read_write: StateROSWS<RT, WT, REL>;
+    readonly read_write: StateROSW<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>;
+    readonly read_write?: StateRESW<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> & {
+type StateSyncRESW<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateRESW<RT, WT, REL> & OwnerWrite$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>;
+    readonly read_write: StateRESW<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>;
+    abstract readonly rsync: boolean;
     get?(): RRT;
+    abstract readonly rok: boolean;
     ok?(): RT;
     sub<T = StateSub<RRT>>(func: StateSub<RRT>, update?: boolean): T;
     unsub<T = StateSub<RRT>>(func: T): T;
@@ -326,12 +318,10 @@ declare abstract class StateBase<RT, WT, REL extends Option<StateRelated>, RRT e
     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>;
+    limit?(value: WT): Promise<Result<WT, string>>;
+    check?(value: WT): Promise<Result<WT, string>>;
     /**Called when subscriber is added*/
     protected on_subscribe(): void;
     /**Called when subscriber is removed*/
@@ -427,7 +417,7 @@ interface StateResourceOwnerREAWA<RT, WT, REL extends Option<StateRelated>> {
     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 read_write(): StateREAW<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;
@@ -456,19 +446,19 @@ declare abstract class StateResourceREAWA<RT, WT = RT, REL extends Option<StateR
     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 read_write(): StateREAW<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>;
+    abstract limit(value: WT): Promise<Result<WT, string>>;
+    abstract check(value: WT): Promise<Result<WT, string>>;
 }
-interface OwnerWA$5<RT, WT, REL extends Option<StateRelated>> extends StateResourceOwnerREAWA<RT, WT, REL> {
+interface OwnerWA<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>;
+type StateResourceFuncREAWA<RT, REL extends Option<StateRelated> = Option<{}>, WT = any> = StateREAW<RT, WT, REL> & OwnerWA<RT, WT, REL>;
 
 /**State Resource
  * state for representing a remote resource
@@ -528,133 +518,62 @@ interface Owner$a<RT, WT, REL extends Option<StateRelated>> extends StateResourc
 }
 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>;
+type LazySetter<RT, RRT extends Result<RT, string>, REL extends Option<StateRelated>, WT = RT> = (value: WT, state: OwnerWrite$5<RT, RRT, WT, REL>, old?: RRT) => Promise<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> {
+interface OwnerWrite$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>;
+    readonly read_write?: StateROSW<RT, WT, REL>;
 };
-type StateLazyROSWS<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateROSWS<RT, WT, REL> & OwnerWS$5<RT, ResultOk<RT>, WT, REL> & {
+type StateLazyROSW<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateROSW<RT, WT, REL> & OwnerWrite$5<RT, ResultOk<RT>, WT, REL> & {
     readonly read_only: StateROS<RT, REL, WT>;
-    readonly read_write: StateROSWS<RT, WT, REL>;
+    readonly read_write: StateROSW<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>;
+    readonly read_write?: StateRESW<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> & {
+type StateLazyRESW<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateRESW<RT, WT, REL> & OwnerWrite$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>;
+    readonly read_write: StateRESW<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>>;
+type DelayedSetter<RT, RRT extends Result<RT, string>, REL extends Option<StateRelated>, WT = RT> = (value: WT, state: OwnerWrite$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>;
+    setter?: DelayedSetter<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>;
+interface OwnerWrite$4<RT, RRT extends Result<RT, string>, WT, REL extends Option<StateRelated>> extends Owner$8<RT, RRT, WT, REL> {
+    setter: DelayedSetter<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>;
+    readonly read_write?: StateROAW<RT, WT, REL>;
 };
-type StateDelayedROAWA<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateROAWA<RT, WT, REL> & OwnerWA$4<RT, ResultOk<RT>, WT, REL> & {
+type StateDelayedROAW<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateROAW<RT, WT, REL> & OwnerWrite$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>;
+    readonly read_write: StateROAW<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>;
+    readonly read_write?: StateREAW<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> & {
+type StateDelayedREAW<RT, WT = RT, REL extends Option<StateRelated> = Option<{}>> = StateREAW<RT, WT, REL> & OwnerWrite$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>;
+    readonly read_write: StateREAW<RT, WT, REL>;
 };
 
 type StateCollectedTransVal<IN extends State<any>[]> = {
@@ -807,35 +726,23 @@ interface Owner$3<S, RIN, ROUT, WIN, WOUT> {
     /**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;
+    set_transform_write(wout_win: (val: WOUT) => WIN, win_wout: (val: WIN) => WOUT): 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> {
+interface OwnerWrite$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;
+    set_transform_write(wout_win: (val: WOUT) => WIN, win_wout: (val: WIN) => WOUT): void;
     get state(): State<ROUT, WOUT, OptionNone>;
     get read_only(): StateREA<ROUT, OptionNone, WOUT>;
-    get read_write(): StateREAWS<ROUT, WOUT, OptionNone>;
+    get read_write(): StateREAW<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>;
+type StateProxyREAW<S extends StateREAW<RIN, WIN>, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> = StateREAW<ROUT, WOUT, OptionNone> & OwnerWrite$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*/
@@ -843,35 +750,23 @@ interface Owner$2<S, RIN, ROUT, WIN, WOUT> {
     /**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;
+    set_transform_write(wout_win: (val: WOUT) => WIN, win_wout: (val: WIN) => WOUT): 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> {
+interface OwnerWrite$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;
+    set_transform_write(wout_win: (val: WOUT) => WIN, win_wout: (val: WIN) => WOUT): void;
     get state(): State<ROUT, WOUT, OptionNone>;
     get read_only(): StateRES<ROUT, OptionNone, WOUT>;
-    get read_write(): StateRESWS<ROUT, WOUT, OptionNone>;
+    get read_write(): StateRESW<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>;
+type StateProxyRESW<S extends StateRESW<RIN, WIN>, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> = StateRESW<ROUT, WOUT, OptionNone> & OwnerWrite$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*/
@@ -879,36 +774,24 @@ interface Owner$1<S extends State<any, any>, RIN, ROUT, WIN, WOUT> {
     /**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;
+    set_transform_write(wout_win: (val: WOUT) => WIN, win_wout: (val: WIN) => WOUT): 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> {
+interface OwnerWrite$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;
+    set_transform_write(wout_win: (val: WOUT) => WIN, win_wout: (val: WIN) => WOUT): void;
     get state(): State<ROUT, WOUT, OptionNone>;
     get read_only(): StateROA<ROUT, OptionNone, WOUT>;
-    get read_write(): StateROAWS<ROUT, WOUT, OptionNone>;
+    get read_write(): StateROAW<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>;
+type StateProxyROAW<S extends StateREAW<RIN, WIN>, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> = StateROAW<ROUT, WOUT, OptionNone> & OwnerWrite$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*/
@@ -916,36 +799,24 @@ interface Owner<S extends State<any, any>, RIN, ROUT, WIN, WOUT> {
     /**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;
+    set_transform_write(wout_win: (val: WOUT) => WIN, win_wout: (val: WIN) => WOUT): 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> {
+interface OwnerWrite<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;
+    set_transform_write(wout_win: (val: WOUT) => WIN, win_wout: (val: WIN) => WOUT): void;
     get state(): State<ROUT, WOUT, OptionNone>;
     get read_only(): StateROS<ROUT, OptionNone, WOUT>;
-    get read_write(): StateROSWS<ROUT, WOUT, OptionNone>;
+    get read_write(): StateROSW<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>;
+type StateProxyROSW<S extends StateRESW<RIN, WIN>, RIN = S extends State<infer RT> ? RT : never, WIN = S extends State<any, infer WT> ? WT : never, ROUT = RIN, WOUT = WIN> = StateROSW<ROUT, WOUT, OptionNone> & OwnerWrite<S, RIN, WIN, ROUT, WOUT>;
 
 declare const state: {
     /**The state key is a symbol used to identify state objects
@@ -983,7 +854,7 @@ declare const state: {
             }, 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>, {
+            ok<AT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init: AT[] | undefined, setter: StateSetREXWS<StateArrayRead<AT>, OwnerWS<AT, _chocbite_ts_lib_result.ResultOk<StateArrayRead<AT>>, REL>, {
                 type: "pop";
             } | {
                 type: "shift";
@@ -1090,7 +961,7 @@ declare const state: {
             }, 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>, {
+            ok<AT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init: AT[] | undefined, setter: StateSetREXWS<StateArrayRead<AT>, OwnerWS<AT, _chocbite_ts_lib_result.Result<StateArrayRead<AT>, string>, REL>, {
                 type: "pop";
             } | {
                 type: "shift";
@@ -1141,7 +1012,7 @@ declare const state: {
                 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>, {
+            err<AT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(error: string, setter: StateSetREXWS<StateArrayRead<AT>, OwnerWS<AT, _chocbite_ts_lib_result.Result<StateArrayRead<AT>, string>, REL>, {
                 type: "pop";
             } | {
                 type: "shift";
@@ -1242,28 +1113,19 @@ declare const state: {
             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>;
+        roaw: {
+            ok<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init?: () => PromiseLike<RT>, setter?: ((value: WT, state: OwnerWrite$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>): StateDelayedROAW<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: OwnerWrite$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>): StateDelayedROAW<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>;
+        reaw: {
+            ok<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init?: () => PromiseLike<RT>, setter?: ((value: WT, state: OwnerWrite$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>): StateDelayedREAW<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: OwnerWrite$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>): StateDelayedREAW<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: OwnerWrite$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>): StateDelayedREAW<RT, WT, REL>;
         };
     };
     h: {
@@ -1272,20 +1134,16 @@ declare const state: {
             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>;
+            reaw(s: any): s is StateREAW<any>;
+            roaw(s: any): s is StateROAW<any>;
+            resw(s: any): s is StateRESW<any>;
+            rosw(s: any): s is StateROSW<any>;
         };
         nums: {
-            helper(min?: number, max?: number, unit?: string, decimals?: number, step?: number, start?: number): StateNumberHelper;
+            helper(min?: State<number>, max?: State<number>, unit?: State<string>, decimals?: State<number>, step?: State<number>, start?: State<number>, writable?: State<boolean>): StateNumberHelper;
         };
         strings: {
-            helper(max_length?: number, max_length_bytes?: number): StateStringHelper;
+            helper(max_length?: State<number>, max_length_bytes?: State<number>, writable?: State<boolean>): StateStringHelper;
         };
         enums: {
             helper<L extends {
@@ -1294,7 +1152,7 @@ declare const state: {
                     description?: string;
                     icon?: _chocbite_ts_lib_svg.SVGFunc;
                 };
-            }, K extends PropertyKey = keyof L, R extends StateRelated = StateEnumRelated<L>>(list: L): StateEnumHelper<L, K, R>;
+            }, K extends PropertyKey = keyof L, R extends StateRelatedBase = StateEnumRelated<L>>(list: State<L>, writable?: State<boolean>): StateEnumHelper<L, K, R>;
             list<K extends PropertyKey>(list: { [P in K]: {
                 name: string;
                 description?: string;
@@ -1311,8 +1169,8 @@ declare const state: {
             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>;
+            ok<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init: () => RT, setter?: ((value: WT, state: OwnerWrite$5<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>): StateLazyROSW<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: OwnerWrite$5<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>): StateLazyROSW<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>;
@@ -1320,9 +1178,9 @@ declare const state: {
             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>;
+            ok<RT, WT = RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>>(init: () => RT, setter?: ((value: WT, state: OwnerWrite$5<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>): StateLazyRESW<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: OwnerWrite$5<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>): StateLazyRESW<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: OwnerWrite$5<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>): StateLazyRESW<RT, WT, REL>;
         };
     };
     p: {
@@ -1330,49 +1188,57 @@ declare const state: {
             <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>;
+        rosw: {
+            <S extends StateROSW<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateROSW<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.ResultOk<ROUT>, transform_write?: {
+                wout_win: (val: WOUT) => WIN;
+                win_wout: (val: WIN) => WOUT;
+            }): StateProxyROSW<S, RIN, WIN, ROUT, WOUT>;
+            <S extends StateRESW<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateRESW<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.ResultOk<ROUT>, transform_write?: {
+                wout_win: (val: WOUT) => WIN;
+                win_wout: (val: WIN) => WOUT;
+            }): StateProxyROSW<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>;
+        roaw: {
+            <S extends StateROAW<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateROAW<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.ResultOk<ROUT>, transform_write?: {
+                wout_win: (val: WOUT) => WIN;
+                win_wout: (val: WIN) => WOUT;
+            }): StateProxyROAW<S, RIN, WIN, ROUT, WOUT>;
+            <S extends StateREAW<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateREAW<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.ResultOk<ROUT>, transform_write?: {
+                wout_win: (val: WOUT) => WIN;
+                win_wout: (val: WIN) => WOUT;
+            }): StateProxyROAW<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>;
+        resw: {
+            <S extends StateROSW<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateROSW<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.Result<ROUT, string>, transform_write?: {
+                wout_win: (val: WOUT) => WIN;
+                win_wout: (val: WIN) => WOUT;
+            }): StateProxyRESW<S, RIN, WIN, ROUT, WOUT>;
+            <S extends StateRESW<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateRESW<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.Result<ROUT, string>, transform_write?: {
+                wout_win: (val: WOUT) => WIN;
+                win_wout: (val: WIN) => WOUT;
+            }): StateProxyRESW<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>;
+        reaw: {
+            <S extends StateROAW<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateROAW<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.ResultOk<RIN>) => _chocbite_ts_lib_result.Result<ROUT, string>, transform_write?: {
+                wout_win: (val: WOUT) => WIN;
+                win_wout: (val: WIN) => WOUT;
+            }): StateProxyREAW<S, RIN, WIN, ROUT, WOUT>;
+            <S extends StateREAW<RIN, WIN>, RIN, WIN, ROUT = RIN, WOUT = WIN>(state: StateREAW<RIN, WIN>, transform_read?: (value: _chocbite_ts_lib_result.Result<RIN, string>) => _chocbite_ts_lib_result.Result<ROUT, string>, transform_write?: {
+                wout_win: (val: WOUT) => WIN;
+                win_wout: (val: WIN) => WOUT;
+            }): StateProxyREAW<S, RIN, WIN, ROUT, WOUT>;
         };
     };
     r: {
@@ -1395,7 +1261,7 @@ declare const state: {
             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?: {
+            from<RT, REL extends _chocbite_ts_lib_result.Option<StateRelated> = _chocbite_ts_lib_result.Option<{}>, WT = RT>(once: (state: OwnerWA<RT, WT, REL>) => void, setup: (state: OwnerWA<RT, WT, REL>) => void, teardown: () => void, write_action?: (value: WT, state: OwnerWA<RT, WT, REL>) => Promise<_chocbite_ts_lib_result.Result<void, string>>, times?: {
                 timeout?: number;
                 debounce?: number;
                 validity?: number | true;
@@ -1411,8 +1277,8 @@ declare const state: {
             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>;
+            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: OwnerWrite$6<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>): StateSyncROSW<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: OwnerWrite$6<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>): StateSyncROSW<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>;
@@ -1420,9 +1286,9 @@ declare const state: {
             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>;
+            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: OwnerWrite$6<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>): StateSyncRESW<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: OwnerWrite$6<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>): StateSyncRESW<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: OwnerWrite$6<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>): StateSyncRESW<RT, WT, REL>;
         };
     };
     /**Returns true if the given object promises to be a state */
@@ -1432,9 +1298,9 @@ declare const state: {
     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>;
+    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: OwnerWrite$6<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>) => StateSyncROSW<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: OwnerWrite$6<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>) => StateSyncRESW<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: OwnerWrite$6<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>) => StateSyncRESW<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 as default, state };
+export { type State, type StateArray, type StateArrayREA, type StateArrayREAW, type StateArrayRES, type StateArrayRESW, type StateArrayROA, type StateArrayROAW, type StateArrayROS, type StateArrayROSW, type StateArrayRead, StateArrayReadType, type StateArraySyncRES, type StateArraySyncRESWS, type StateArraySyncROS, type StateArraySyncROSWS, type StateArrayWrite, type StateCollectedREA, type StateCollectedRES, type StateCollectedROA, type StateCollectedROS, type StateDelayedREA, type StateDelayedREAW, type StateDelayedROA, type StateDelayedROAW, StateEnumHelper, type StateEnumRelated, type StateInferResult, type StateInferSub, type StateInferType, type StateLazyRES, type StateLazyRESW as StateLazyRESWS, type StateLazyROS, type StateLazyROSW as StateLazyROSWS, StateNumberHelper, type StateNumberRelated, type StateProxyREA, type StateProxyREAW as StateProxyREAWA, type StateProxyRES, type StateProxyRESW as StateProxyRESWA, type StateProxyROA, type StateProxyROAW as StateProxyROAWA, type StateProxyROS, type StateProxyROSW as StateProxyROSWA, type StateREA, type StateREAW, type StateRES, type StateRESW, type StateROA, type StateROAW, type StateROS, type StateROSW, type StateResourceFuncREA, type StateResourceFuncREAWA, type StateResourceFuncROA, StateResourceREA, StateResourceREAWA, StateResourceROA, StateStringHelper, type StateStringRelated, type StateSub, type StateSyncRES, type StateSyncRESW as StateSyncRESWS, type StateSyncROS, type StateSyncROSW as StateSyncROSWS, state as default, state };