npm - ballerina-core - Versions diffs - 1.0.232 → 1.0.234 - Mend

ballerina-core 1.0.232 → 1.0.234

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1017) hide show

package/bin/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/builder.d.ts CHANGED Viewed

@@ -19,7 +19,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>[]) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -39,7 +38,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     GetState: () => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -60,7 +58,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -80,7 +77,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }>;
     SetState: (stateUpdater: import("../../../../../../../../../main").BasicUpdater<TableAbstractRendererState>) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -101,7 +97,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     UpdateState: (stateUpdater: import("../../../../../../../../fun/state").BasicFun<TableAbstractRendererState, import("../../../../../../../../../main").BasicUpdater<TableAbstractRendererState>>) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -122,7 +117,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     Any: (ps: import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -143,7 +137,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>[]) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -163,7 +156,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     All: <result>(ps: import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -184,7 +176,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, result>[]) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -204,7 +195,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, result[]>;
     Yield: (next: import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -225,7 +215,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -245,7 +234,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     Wait: (ms: number) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -266,7 +254,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     Await: <r, err>(p: import("../../../../../../../../fun/state").BasicFun<Unit, Promise<r>>, onErr: import("../../../../../../../../fun/state").BasicFun<any, err>, debugName?: string) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -287,7 +274,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, import("../../../../../../../../../main").Sum<r, err>>;
     Repeat: (p: import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -308,7 +294,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -328,7 +313,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     Return: <r>(res: r) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -349,7 +333,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, r>;
     While: (predicate: import("../../../../../../../../fun/state").BasicFun<[import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -370,7 +353,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }], boolean>, p: import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -390,7 +372,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -410,7 +391,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     For: <element>(collection: import("immutable").Collection<number, element>) => (p: import("../../../../../../../../fun/state").BasicFun<element, import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -431,7 +411,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>>) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -451,7 +430,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     Embed: <parentContext, parentState, result>(p: import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -472,7 +450,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, result>, narrow: import("../../../../../../../../fun/state").BasicFun<parentContext & parentState, import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -492,7 +469,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }>, widen: import("../../../../../../../../fun/state").BasicFun<import("../../../../../../../../../main").BasicUpdater<TableAbstractRendererState>, import("../../../../../../../../../main").BasicUpdater<parentState>>) => import("../../../../../../../../coroutines/state").Coroutine<parentContext & parentState, parentState, result>;
     Template: <fm>(initialCoroutine: import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -513,7 +489,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>, options?: import("../../../../../../../../coroutines/template").CoroutineComponentOptions<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -533,7 +508,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState> | undefined) => import("../../../../../../../../template/state").Template<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -553,7 +527,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, fm>;
     Trigger: <event_1 extends {
@@ -577,7 +550,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     } & {
         outboundEvents: import("immutable").Map<kind, import("immutable").OrderedMap<string, event_1>>;
@@ -593,7 +565,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     } & {
         outboundEvents: import("immutable").Map<kind, import("immutable").OrderedMap<string, event_1>>;
@@ -616,7 +587,6 @@ export declare const Co: <CustomPresentationContext = Unit, ExtraContext = Unit>
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
 };
@@ -639,7 +609,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>[]) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -659,7 +628,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     GetState: () => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -680,7 +648,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -700,7 +667,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }>;
     SetState: (stateUpdater: import("../../../../../../../../../main").BasicUpdater<TableAbstractRendererState>) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -721,7 +687,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     UpdateState: (stateUpdater: import("../../../../../../../../fun/state").BasicFun<TableAbstractRendererState, import("../../../../../../../../../main").BasicUpdater<TableAbstractRendererState>>) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -742,7 +707,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     Any: (ps: import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -763,7 +727,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>[]) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -783,7 +746,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     All: <result>(ps: import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -804,7 +766,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, result>[]) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -824,7 +785,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, result[]>;
     Yield: (next: import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -845,7 +805,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -865,7 +824,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     Wait: (ms: number) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -886,7 +844,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     Await: <r, err>(p: import("../../../../../../../../fun/state").BasicFun<Unit, Promise<r>>, onErr: import("../../../../../../../../fun/state").BasicFun<any, err>, debugName?: string) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -907,7 +864,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, import("../../../../../../../../../main").Sum<r, err>>;
     Repeat: (p: import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -928,7 +884,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -948,7 +903,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     Return: <r>(res: r) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -969,7 +923,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, r>;
     While: (predicate: import("../../../../../../../../fun/state").BasicFun<[import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -990,7 +943,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }], boolean>, p: import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -1010,7 +962,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -1030,7 +981,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     For: <element>(collection: import("immutable").Collection<number, element>) => (p: import("../../../../../../../../fun/state").BasicFun<element, import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -1051,7 +1001,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>>) => import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -1071,7 +1020,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
     Embed: <parentContext, parentState, result>(p: import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -1092,7 +1040,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, result>, narrow: import("../../../../../../../../fun/state").BasicFun<parentContext & parentState, import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -1112,7 +1059,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }>, widen: import("../../../../../../../../fun/state").BasicFun<import("../../../../../../../../../main").BasicUpdater<TableAbstractRendererState>, import("../../../../../../../../../main").BasicUpdater<parentState>>) => import("../../../../../../../../coroutines/state").Coroutine<parentContext & parentState, parentState, result>;
     Template: <fm>(initialCoroutine: import("../../../../../../../../coroutines/state").Coroutine<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -1133,7 +1079,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>, options?: import("../../../../../../../../coroutines/template").CoroutineComponentOptions<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -1153,7 +1098,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState> | undefined) => import("../../../../../../../../template/state").Template<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
         tableHeaders: string[];
@@ -1173,7 +1117,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, fm>;
     Trigger: <event_1 extends {
@@ -1197,7 +1140,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     } & {
         outboundEvents: import("immutable").Map<kind, import("immutable").OrderedMap<string, event_1>>;
@@ -1213,7 +1155,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     } & {
         outboundEvents: import("immutable").Map<kind, import("immutable").OrderedMap<string, event_1>>;
@@ -1236,7 +1177,6 @@ export declare const InfiniteLoaderCo: <CustomPresentationContext = Unit, ExtraC
             sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
             filterAndSortParam: string;
             filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-            applyToAll: boolean;
         };
     }, TableAbstractRendererState, Unit>;
 };

package/bin/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/builder.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,6CAA6C,EAC9C,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAEL,0BAA0B,EAC1B,IAAI,EACL,MAAM,iCAAiC,CAAC;AAEzC,eAAO,MAAM,EAAE,GAAI,yBAAyB,GAAG,IAAI,EAAE,YAAY,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOnE,CAAC;AAEN,eAAO,MAAM,gBAAgB,GAC3B,yBAAyB,GAAG,IAAI,EAChC,YAAY,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAShB,CAAC"}
1	+ {"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,6CAA6C,EAC9C,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAEL,0BAA0B,EAC1B,IAAI,EACL,MAAM,iCAAiC,CAAC;AAEzC,eAAO,MAAM,EAAE,GAAI,yBAAyB,GAAG,IAAI,EAAE,YAAY,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOnE,CAAC;AAEN,eAAO,MAAM,gBAAgB,GAC3B,yBAAyB,GAAG,IAAI,EAChC,YAAY,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAShB,CAAC"}

package/bin/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/infiniteLoader.d.ts CHANGED Viewed

@@ -18,7 +18,6 @@ export declare const TableInfiniteLoader: <CustomPresentationContext = Unit, Ext
         sorting: Map<string, "Ascending" | "Descending" | undefined>;
         filterAndSortParam: string;
         filterStates: Map<string, import("immutable").List<any>>;
-        applyToAll: boolean;
     };
 }, TableAbstractRendererState, Unit>;
 //# sourceMappingURL=infiniteLoader.d.ts.map

package/bin/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/infiniteLoader.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"infiniteLoader.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/infiniteLoader.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,sBAAsB,EAEtB,cAAc,EACd,0BAA0B,EAE1B,IAAI,EACJ,aAAa,EACb,UAAU,EACX,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAGhC,eAAO,MAAM,mBAAmB,GAC9B,yBAAyB,GAAG,IAAI,EAChC,YAAY,GAAG,IAAI,EAEnB,gBAAgB,sBAAsB,EACtC,oBAAoB,CAAC,KAAK,EAAE,OAAO,KAAK,aAAa,CAAC,cAAc,EAAE,MAAM,CAAC~~;;;;;;;;;;;;;;;;;;;;~~oCA4D9E,CAAC"}
1	+ {"version":3,"file":"infiniteLoader.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/infiniteLoader.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,sBAAsB,EAEtB,cAAc,EACd,0BAA0B,EAE1B,IAAI,EACJ,aAAa,EACb,UAAU,EACX,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAGhC,eAAO,MAAM,mBAAmB,GAC9B,yBAAyB,GAAG,IAAI,EAChC,YAAY,GAAG,IAAI,EAEnB,gBAAgB,sBAAsB,EACtC,oBAAoB,CAAC,KAAK,EAAE,OAAO,KAAK,aAAa,CAAC,cAAc,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;oCA4D9E,CAAC"}

package/bin/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/initialiseFiltersAndSorting.d.ts CHANGED Viewed

@@ -18,7 +18,6 @@ export declare const InitialiseFiltersAndSorting: <CustomPresentationContext = U
         sorting: Map<string, "Ascending" | "Descending" | undefined>;
         filterAndSortParam: string;
         filterStates: Map<string, import("immutable").List<any>>;
-        applyToAll: boolean;
     };
 }, TableAbstractRendererState, Unit>;
 //# sourceMappingURL=initialiseFiltersAndSorting.d.ts.map

package/bin/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/initialiseFiltersAndSorting.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"initialiseFiltersAndSorting.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/initialiseFiltersAndSorting.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAChC,OAAO,EACL,SAAS,EACT,kBAAkB,EAClB,sBAAsB,EAEtB,cAAc,EAGd,QAAQ,EAER,0BAA0B,EAC1B,IAAI,EACJ,aAAa,EACd,MAAM,iCAAiC,CAAC;AAGzC,eAAO,MAAM,2BAA2B,GACtC,yBAAyB,GAAG,IAAI,EAChC,YAAY,GAAG,IAAI,EAEnB,gBAAgB,sBAAsB,EACtC,oBAAoB,CAClB,IAAI,EAAE,kBAAkB,CAAC,GAAG,CAAC,KAC1B,CAAC,GAAG,EAAE,GAAG,KAAK,aAAa,CAAC,cAAc,EAAE,MAAM,CAAC,EACxD,kBAAkB,CAChB,IAAI,EAAE,kBAAkB,CAAC,GAAG,CAAC,EAC7B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,GAAG,KACP,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC,EAC/B,aAAa,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC~~;;;;;;;;;;;;;;;;;;;;~~oCAgFxC,CAAC"}
1	+ {"version":3,"file":"initialiseFiltersAndSorting.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/initialiseFiltersAndSorting.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAChC,OAAO,EACL,SAAS,EACT,kBAAkB,EAClB,sBAAsB,EAEtB,cAAc,EAGd,QAAQ,EAER,0BAA0B,EAC1B,IAAI,EACJ,aAAa,EACd,MAAM,iCAAiC,CAAC;AAGzC,eAAO,MAAM,2BAA2B,GACtC,yBAAyB,GAAG,IAAI,EAChC,YAAY,GAAG,IAAI,EAEnB,gBAAgB,sBAAsB,EACtC,oBAAoB,CAClB,IAAI,EAAE,kBAAkB,CAAC,GAAG,CAAC,KAC1B,CAAC,GAAG,EAAE,GAAG,KAAK,aAAa,CAAC,cAAc,EAAE,MAAM,CAAC,EACxD,kBAAkB,CAChB,IAAI,EAAE,kBAAkB,CAAC,GAAG,CAAC,EAC7B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,GAAG,KACP,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC,EAC/B,aAAa,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;;;;;;;;;;;;;;;;;;;oCAgFxC,CAAC"}

package/bin/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/initialiseTable.d.ts CHANGED Viewed

@@ -17,7 +17,6 @@ export declare const InitialiseTable: <CustomPresentationContext = Unit, ExtraCo
         sorting: import("immutable").Map<string, "Ascending" | "Descending" | undefined>;
         filterAndSortParam: string;
         filterStates: import("immutable").Map<string, import("immutable").List<any>>;
-        applyToAll: boolean;
     };
 }, TableAbstractRendererState, Unit>;
 //# sourceMappingURL=initialiseTable.d.ts.map

package/bin/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/initialiseTable.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"initialiseTable.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/initialiseTable.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,sBAAsB,EAEtB,cAAc,EACd,0BAA0B,EAE1B,IAAI,EACJ,aAAa,EACb,UAAU,EACX,MAAM,iCAAiC,CAAC;AAKzC,eAAO,MAAM,eAAe,GAC1B,yBAAyB,GAAG,IAAI,EAChC,YAAY,GAAG,IAAI,EAEnB,gBAAgB,sBAAsB,EACtC,oBAAoB,CAAC,KAAK,EAAE,OAAO,KAAK,aAAa,CAAC,cAAc,EAAE,MAAM,CAAC~~;;;;;;;;;;;;;;;;;;;;~~oCAkE9E,CAAC"}
1	+ {"version":3,"file":"initialiseTable.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/initialiseTable.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,sBAAsB,EAEtB,cAAc,EACd,0BAA0B,EAE1B,IAAI,EACJ,aAAa,EACb,UAAU,EACX,MAAM,iCAAiC,CAAC;AAKzC,eAAO,MAAM,eAAe,GAC1B,yBAAyB,GAAG,IAAI,EAChC,YAAY,GAAG,IAAI,EAEnB,gBAAgB,sBAAsB,EACtC,oBAAoB,CAAC,KAAK,EAAE,OAAO,KAAK,aAAa,CAAC,cAAc,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;oCAkE9E,CAAC"}

package/bin/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/runner.d.ts CHANGED Viewed

@@ -18,7 +18,6 @@ export declare const TableInitialiseFiltersAndSortingRunner: <CustomPresentation
         sorting: Map<string, "Ascending" | "Descending" | undefined>;
         filterAndSortParam: string;
         filterStates: Map<string, import("immutable").List<any>>;
-        applyToAll: boolean;
     };
 }, import("../state").TableAbstractRendererState, any>;
 export declare const TableInitialiseTableRunner: <CustomPresentationContext = Unit, ExtraContext = Unit>(tableApiSource: DispatchTableApiSource, fromTableApiParser: (value: unknown) => ValueOrErrors<PredicateValue, string>) => import("../../../../../../../../template/state").Template<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -39,7 +38,6 @@ export declare const TableInitialiseTableRunner: <CustomPresentationContext = Un
         sorting: Map<string, "Ascending" | "Descending" | undefined>;
         filterAndSortParam: string;
         filterStates: Map<string, import("immutable").List<any>>;
-        applyToAll: boolean;
     };
 }, import("../state").TableAbstractRendererState, any>;
 export declare const TableInfiniteLoaderRunner: <CustomPresentationContext = Unit, ExtraContext = Unit>(tableApiSource: DispatchTableApiSource, fromTableApiParser: (value: unknown) => ValueOrErrors<PredicateValue, string>) => import("../../../../../../../../template/state").Template<import("../../state").CommonAbstractRendererReadonlyContext<import("../../../../../../../../../main").TableType<any>, import("../../../../../../parser/domains/predicates/state").ValueTable, CustomPresentationContext, ExtraContext> & {
@@ -60,7 +58,6 @@ export declare const TableInfiniteLoaderRunner: <CustomPresentationContext = Uni
         sorting: Map<string, "Ascending" | "Descending" | undefined>;
         filterAndSortParam: string;
         filterStates: Map<string, import("immutable").List<any>>;
-        applyToAll: boolean;
     };
 }, import("../state").TableAbstractRendererState, any>;
 //# sourceMappingURL=runner.d.ts.map

package/bin/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/runner.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAErC,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,cAAc,EACd,QAAQ,EACR,IAAI,EACJ,aAAa,EACd,MAAM,iCAAiC,CAAC;AAOzC,eAAO,MAAM,sCAAsC,GACjD,yBAAyB,GAAG,IAAI,EAChC,YAAY,GAAG,IAAI,EAEnB,aAAa,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,EACvC,gBAAgB,sBAAsB,EACtC,oBAAoB,CAClB,IAAI,EAAE,kBAAkB,CAAC,GAAG,CAAC,KAC1B,CAAC,GAAG,EAAE,GAAG,KAAK,aAAa,CAAC,cAAc,EAAE,MAAM,CAAC,EACxD,kBAAkB,CAChB,IAAI,EAAE,kBAAkB,CAAC,GAAG,CAAC,EAC7B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,GAAG,KACP,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC~~;;;;;;;;;;;;;;;;;;;;~~sDAc9B,CAAC;AAEJ,eAAO,MAAM,0BAA0B,GACrC,yBAAyB,GAAG,IAAI,EAChC,YAAY,GAAG,IAAI,EAEnB,gBAAgB,sBAAsB,EACtC,oBAAoB,CAAC,KAAK,EAAE,OAAO,KAAK,aAAa,CAAC,cAAc,EAAE,MAAM,CAAC~~;;;;;;;;;;;;;;;;;;;;~~sDAc5E,CAAC;AAEJ,eAAO,MAAM,yBAAyB,GACpC,yBAAyB,GAAG,IAAI,EAChC,YAAY,GAAG,IAAI,EAEnB,gBAAgB,sBAAsB,EACtC,oBAAoB,CAAC,KAAK,EAAE,OAAO,KAAK,aAAa,CAAC,cAAc,EAAE,MAAM,CAAC~~;;;;;;;;;;;;;;;;;;;;~~sDAe5E,CAAC"}
1	+ {"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAErC,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,cAAc,EACd,QAAQ,EACR,IAAI,EACJ,aAAa,EACd,MAAM,iCAAiC,CAAC;AAOzC,eAAO,MAAM,sCAAsC,GACjD,yBAAyB,GAAG,IAAI,EAChC,YAAY,GAAG,IAAI,EAEnB,aAAa,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,EACvC,gBAAgB,sBAAsB,EACtC,oBAAoB,CAClB,IAAI,EAAE,kBAAkB,CAAC,GAAG,CAAC,KAC1B,CAAC,GAAG,EAAE,GAAG,KAAK,aAAa,CAAC,cAAc,EAAE,MAAM,CAAC,EACxD,kBAAkB,CAChB,IAAI,EAAE,kBAAkB,CAAC,GAAG,CAAC,EAC7B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,GAAG,KACP,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;sDAc9B,CAAC;AAEJ,eAAO,MAAM,0BAA0B,GACrC,yBAAyB,GAAG,IAAI,EAChC,YAAY,GAAG,IAAI,EAEnB,gBAAgB,sBAAsB,EACtC,oBAAoB,CAAC,KAAK,EAAE,OAAO,KAAK,aAAa,CAAC,cAAc,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;sDAc5E,CAAC;AAEJ,eAAO,MAAM,yBAAyB,GACpC,yBAAyB,GAAG,IAAI,EAChC,YAAY,GAAG,IAAI,EAEnB,gBAAgB,sBAAsB,EACtC,oBAAoB,CAAC,KAAK,EAAE,OAAO,KAAK,aAAa,CAAC,cAAc,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;sDAe5E,CAAC"}