ballerina-core 1.0.220 → 1.0.222

package/bin/src/forms/domains/dispatched-forms/deserializer/coroutines/runner.d.ts

@@ -1,4 +1,24 @@
 import { Unit, DispatchInjectablesTypes } from "../../../../../../main";
 import { DispatchFormsParserContext, DispatchFormsParserState } from "../state";
-export declare const LoadAndDeserializeSpecification: <T extends DispatchInjectablesTypes<T>, Flags = Unit, CustomPresentationContexts = Unit, ExtraContext = Unit>() => import("../../../../../template/state").Template<DispatchFormsParserContext<T, Flags, CustomPresentationContexts, ExtraContext> & DispatchFormsParserState<T, Flags, CustomPresentationContexts, ExtraContext>, DispatchFormsParserState<T, Flags, CustomPresentationContexts, ExtraContext>, Unit>;
-//# sourceMappingURL=runner.d.ts.map
+export declare const LoadAndDeserializeSpecification: <
+  T extends DispatchInjectablesTypes<T>,
+  Flags = Unit,
+  CustomPresentationContexts = Unit,
+  ExtraContext = Unit,
+>() => import("../../../../../template/state").Template<
+  DispatchFormsParserContext<
+    T,
+    Flags,
+    CustomPresentationContexts,
+    ExtraContext
+  > &
+    DispatchFormsParserState<
+      T,
+      Flags,
+      CustomPresentationContexts,
+      ExtraContext
+    >,
+  DispatchFormsParserState<T, Flags, CustomPresentationContexts, ExtraContext>,
+  Unit
+>;
+//# sourceMappingURL=runner.d.ts.map

package/bin/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/apis/state.d.ts

@@ -1,106 +1,162 @@
 import { List, Map } from "immutable";
-import { ConcreteRenderers, DispatchInjectablesTypes, DispatchInjectedPrimitives, EntityApi, Renderer, ValueOrErrors } from "../../../../../../../../../main";
+import {
+  ConcreteRenderers,
+  DispatchInjectablesTypes,
+  DispatchInjectedPrimitives,
+  EntityApi,
+  Renderer,
+  ValueOrErrors,
+} from "../../../../../../../../../main";
 import { DispatchParsedType, DispatchTypeName, SumNType } from "../types/state";
 export type SerializedEntityApi = {
-    type?: any;
-    methods?: any;
+  type?: any;
+  methods?: any;
 };
 export type SerializedLookupApi = {
-    enums?: unknown;
-    streams?: unknown;
-    one?: unknown;
-    many?: unknown;
-    tables?: unknown;
+  enums?: unknown;
+  streams?: unknown;
+  one?: unknown;
+  many?: unknown;
+  tables?: unknown;
 };
 export type SpecificationApis<T> = {
-    entities: Map<string, EntityApi>;
-    enums?: EnumApis;
-    streams?: StreamApis;
-    tables?: TableApis<T>;
-    lookups?: LookupApis;
+  entities: Map<string, EntityApi>;
+  enums?: EnumApis;
+  streams?: StreamApis;
+  tables?: TableApis<T>;
+  lookups?: LookupApis;
 };
 export type EnumApiName = string;
 export type EnumApis = Map<EnumApiName, DispatchTypeName>;
 export declare const EnumApis: {
-    Operations: {
-        Deserialize: (serializedApiEnums?: unknown) => ValueOrErrors<undefined | EnumApis, string>;
-    };
+  Operations: {
+    Deserialize: (
+      serializedApiEnums?: unknown,
+    ) => ValueOrErrors<undefined | EnumApis, string>;
+  };
 };
 export type StreamApiName = string;
 export type StreamApis = Map<StreamApiName, DispatchTypeName>;
 export declare const StreamApis: {
-    Operations: {
-        Deserialize: (serializedApiStreams?: unknown) => ValueOrErrors<undefined | StreamApis, string>;
-    };
+  Operations: {
+    Deserialize: (
+      serializedApiStreams?: unknown,
+    ) => ValueOrErrors<undefined | StreamApis, string>;
+  };
 };
 type SerializedTableApi = {
-    type: unknown;
-    methods: unknown;
-    highlightedFilters?: unknown;
-    filtering?: unknown;
-    sorting?: unknown;
+  type: unknown;
+  methods: unknown;
+  highlightedFilters?: unknown;
+  filtering?: unknown;
+  sorting?: unknown;
 };
 declare const TableMethods: {
-    readonly add: "add";
-    readonly duplicate: "duplicate";
-    readonly remove: "remove";
-    readonly move: "move";
+  readonly add: "add";
+  readonly duplicate: "duplicate";
+  readonly remove: "remove";
+  readonly move: "move";
 };
 type ColumnName = string;
 export type ColumnFilters<T> = {
-    displayType: DispatchParsedType<T>;
-    displayRenderer: Renderer<T>;
-    filters: SumNType<T>;
+  displayType: DispatchParsedType<T>;
+  displayRenderer: Renderer<T>;
+  filters: SumNType<T>;
 };
 export type TableMethod = (typeof TableMethods)[keyof typeof TableMethods];
 export type TableApiName = string;
 export type TableApiFiltering<T> = Map<ColumnName, ColumnFilters<T>>;
-export type TableApis<T> = Map<TableApiName, {
+export type TableApis<T> = Map<
+  TableApiName,
+  {
     type: DispatchTypeName;
     methods: Array<TableMethod>;
     highlightedFilters?: List<ColumnName>;
     filtering?: TableApiFiltering<T>;
     sorting?: Array<ColumnName>;
-}>;
+  }
+>;
 export declare const TableApis: {
-    Operations: {
-        IsValidTables: (value: unknown) => value is Record<string, SerializedTableApi>;
-        IsValidTableApi: (value: unknown) => value is SerializedTableApi;
-        IsMethod: (value: unknown) => value is TableMethod;
-        IsValidSorting: (value: unknown) => value is Array<ColumnName>;
-        IsMethodsArray: (values: unknown) => values is Array<TableMethod>;
-        IsValidHighlightedFilters: (value: unknown) => value is Array<ColumnName>;
-        DeserializeFiltering: <T extends DispatchInjectablesTypes<T>, Flags, CustomPresentationContexts, ExtraContext>(concreteRenderers: ConcreteRenderers<T, Flags, CustomPresentationContexts, ExtraContext>, types: Map<DispatchTypeName, DispatchParsedType<T>>, serializedFiltering?: unknown, injectedPrimitives?: DispatchInjectedPrimitives<T>) => ValueOrErrors<undefined | TableApiFiltering<T>, string>;
-        Deserialize: <T extends DispatchInjectablesTypes<T>, Flags, CustomPresentationContexts, ExtraContext>(concreteRenderers: ConcreteRenderers<T, Flags, CustomPresentationContexts, ExtraContext>, types: Map<DispatchTypeName, DispatchParsedType<T>>, serializedApiTables?: unknown, injectedPrimitives?: DispatchInjectedPrimitives<T>) => ValueOrErrors<undefined | TableApis<T>, string>;
-    };
+  Operations: {
+    IsValidTables: (
+      value: unknown,
+    ) => value is Record<string, SerializedTableApi>;
+    IsValidTableApi: (value: unknown) => value is SerializedTableApi;
+    IsMethod: (value: unknown) => value is TableMethod;
+    IsValidSorting: (value: unknown) => value is Array<ColumnName>;
+    IsMethodsArray: (values: unknown) => values is Array<TableMethod>;
+    IsValidHighlightedFilters: (value: unknown) => value is Array<ColumnName>;
+    DeserializeFiltering: <
+      T extends DispatchInjectablesTypes<T>,
+      Flags,
+      CustomPresentationContexts,
+      ExtraContext,
+    >(
+      concreteRenderers: ConcreteRenderers<
+        T,
+        Flags,
+        CustomPresentationContexts,
+        ExtraContext
+      >,
+      types: Map<DispatchTypeName, DispatchParsedType<T>>,
+      serializedFiltering?: unknown,
+      injectedPrimitives?: DispatchInjectedPrimitives<T>,
+    ) => ValueOrErrors<undefined | TableApiFiltering<T>, string>;
+    Deserialize: <
+      T extends DispatchInjectablesTypes<T>,
+      Flags,
+      CustomPresentationContexts,
+      ExtraContext,
+    >(
+      concreteRenderers: ConcreteRenderers<
+        T,
+        Flags,
+        CustomPresentationContexts,
+        ExtraContext
+      >,
+      types: Map<DispatchTypeName, DispatchParsedType<T>>,
+      serializedApiTables?: unknown,
+      injectedPrimitives?: DispatchInjectedPrimitives<T>,
+    ) => ValueOrErrors<undefined | TableApis<T>, string>;
+  };
 };
 export type LookupApiName = string;
-export type LookupApis = Map<LookupApiName, {
+export type LookupApis = Map<
+  LookupApiName,
+  {
     one: LookupApiOne;
-}>;
-export type LookupApiOne = Map<string, {
+  }
+>;
+export type LookupApiOne = Map<
+  string,
+  {
     type: DispatchTypeName;
     methods: {
-        get: boolean;
-        update: boolean;
-        getManyUnlinked: boolean;
-        create: boolean;
-        delete: boolean;
+      get: boolean;
+      update: boolean;
+      getManyUnlinked: boolean;
+      create: boolean;
+      delete: boolean;
     };
-}>;
+  }
+>;
 export declare const LookupApis: {
-    Operations: {
-        isOneApi: (_: unknown) => _ is {
-            one: {
-                [key: string]: {
-                    type: DispatchTypeName;
-                    methods: Array<string>;
-                };
-            };
+  Operations: {
+    isOneApi: (_: unknown) => _ is {
+      one: {
+        [key: string]: {
+          type: DispatchTypeName;
+          methods: Array<string>;
         };
-        DeserializeOne: (serializedOneApi: unknown) => ValueOrErrors<LookupApiOne, string>;
-        Deserialize: (serializedApiLookups?: unknown) => ValueOrErrors<undefined | LookupApis, string>;
+      };
     };
+    DeserializeOne: (
+      serializedOneApi: unknown,
+    ) => ValueOrErrors<LookupApiOne, string>;
+    Deserialize: (
+      serializedApiLookups?: unknown,
+    ) => ValueOrErrors<undefined | LookupApis, string>;
+  };
 };
 export {};
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/forms/domains/renderer/domains/enum/state.d.ts

@@ -1,27 +1,43 @@
-import { DispatchInjectablesTypes, Guid, ValueOrErrors } from "../../../../../../../../../../../../../main";
-import { MultiSelectionType, SingleSelectionType } from "../../../../../types/state";
+import {
+  DispatchInjectablesTypes,
+  Guid,
+  ValueOrErrors,
+} from "../../../../../../../../../../../../../main";
+import {
+  MultiSelectionType,
+  SingleSelectionType,
+} from "../../../../../types/state";
 import { SerializedRenderer } from "../../state";
 export type SerializedEnumRenderer = {
-    renderer: string;
-    options: string;
+  renderer: string;
+  options: string;
 };
 export type EnumRenderer<T> = {
-    kind: "enumRenderer";
-    concreteRenderer: string;
-    options: Guid;
-    type: SingleSelectionType<T> | MultiSelectionType<T>;
+  kind: "enumRenderer";
+  concreteRenderer: string;
+  options: Guid;
+  type: SingleSelectionType<T> | MultiSelectionType<T>;
 };
 export declare const EnumRenderer: {
-    Default: <T extends DispatchInjectablesTypes<T>>(type: SingleSelectionType<T> | MultiSelectionType<T>, options: string, concreteRenderer: string) => EnumRenderer<T>;
-    Operations: {
-        hasRenderer: (serialized: unknown) => serialized is object & {
-            renderer: SerializedRenderer;
-        };
-        hasOptions: (serialized: unknown) => serialized is object & {
-            options: string;
-        };
-        tryAsValidEnumRenderer: <T extends DispatchInjectablesTypes<T>>(serialized: unknown) => ValueOrErrors<SerializedEnumRenderer, string>;
-        Deserialize: <T extends DispatchInjectablesTypes<T>>(type: SingleSelectionType<T> | MultiSelectionType<T>, serialized: unknown) => ValueOrErrors<EnumRenderer<T>, string>;
+  Default: <T extends DispatchInjectablesTypes<T>>(
+    type: SingleSelectionType<T> | MultiSelectionType<T>,
+    options: string,
+    concreteRenderer: string,
+  ) => EnumRenderer<T>;
+  Operations: {
+    hasRenderer: (serialized: unknown) => serialized is object & {
+      renderer: SerializedRenderer;
     };
+    hasOptions: (serialized: unknown) => serialized is object & {
+      options: string;
+    };
+    tryAsValidEnumRenderer: <T extends DispatchInjectablesTypes<T>>(
+      serialized: unknown,
+    ) => ValueOrErrors<SerializedEnumRenderer, string>;
+    Deserialize: <T extends DispatchInjectablesTypes<T>>(
+      type: SingleSelectionType<T> | MultiSelectionType<T>,
+      serialized: unknown,
+    ) => ValueOrErrors<EnumRenderer<T>, string>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/forms/domains/renderer/domains/list/state.d.ts

@@ -1,43 +1,75 @@
 import { Map } from "immutable";
-import { ConcreteRenderers, DispatchInjectablesTypes, DispatchParsedType, ListType, ValueOrErrors } from "../../../../../../../../../../../../../main";
+import {
+  ConcreteRenderers,
+  DispatchInjectablesTypes,
+  DispatchParsedType,
+  ListType,
+  ValueOrErrors,
+} from "../../../../../../../../../../../../../main";
 import { NestedRenderer } from "../nestedRenderer/state";
 export type SerializedListRenderer = {
-    renderer: string;
-    elementRenderer: unknown;
-    actions: unknown;
+  renderer: string;
+  elementRenderer: unknown;
+  actions: unknown;
 };
 export declare const ListMethod: {
-    readonly add: "add";
-    readonly remove: "remove";
-    readonly move: "move";
-    readonly duplicate: "duplicate";
+  readonly add: "add";
+  readonly remove: "remove";
+  readonly move: "move";
+  readonly duplicate: "duplicate";
 };
 export type ListMethod = (typeof ListMethod)[keyof typeof ListMethod];
 export type ListMethods = Array<ListMethod>;
 export declare const ListMethods: {
-    Operations: {
-        fromRawValue: (value: unknown) => ValueOrErrors<ListMethods, string>;
-    };
+  Operations: {
+    fromRawValue: (value: unknown) => ValueOrErrors<ListMethods, string>;
+  };
 };
 export type ListRenderer<T> = {
-    kind: "listRenderer";
-    concreteRenderer: string;
-    elementRenderer: NestedRenderer<T>;
-    type: ListType<T>;
-    methods: Array<ListMethod>;
+  kind: "listRenderer";
+  concreteRenderer: string;
+  elementRenderer: NestedRenderer<T>;
+  type: ListType<T>;
+  methods: Array<ListMethod>;
 };
 export declare const ListRenderer: {
-    Default: <T>(type: ListType<T>, concreteRenderer: string, elementRenderer: NestedRenderer<T>, methods?: ListRenderer<T>["methods"]) => ListRenderer<T>;
-    Operations: {
-        hasRenderers: (serialized: unknown) => serialized is object & {
-            renderer: string;
-            elementRenderer: unknown;
-        };
-        tryAsValidBaseListRenderer: <T>(serialized: unknown, type: DispatchParsedType<T>) => ValueOrErrors<Omit<SerializedListRenderer, "renderer" | "elementRenderer"> & {
-            renderer: string;
-            elementRenderer: unknown;
-        }, string>;
-        Deserialize: <T extends DispatchInjectablesTypes<T>, Flags, CustomPresentationContexts, ExtraContext>(type: ListType<T>, serialized: unknown, concreteRenderers: ConcreteRenderers<T, Flags, CustomPresentationContexts, ExtraContext>, types: Map<string, DispatchParsedType<T>>) => ValueOrErrors<ListRenderer<T>, string>;
+  Default: <T>(
+    type: ListType<T>,
+    concreteRenderer: string,
+    elementRenderer: NestedRenderer<T>,
+    methods?: ListRenderer<T>["methods"],
+  ) => ListRenderer<T>;
+  Operations: {
+    hasRenderers: (serialized: unknown) => serialized is object & {
+      renderer: string;
+      elementRenderer: unknown;
     };
+    tryAsValidBaseListRenderer: <T>(
+      serialized: unknown,
+      type: DispatchParsedType<T>,
+    ) => ValueOrErrors<
+      Omit<SerializedListRenderer, "renderer" | "elementRenderer"> & {
+        renderer: string;
+        elementRenderer: unknown;
+      },
+      string
+    >;
+    Deserialize: <
+      T extends DispatchInjectablesTypes<T>,
+      Flags,
+      CustomPresentationContexts,
+      ExtraContext,
+    >(
+      type: ListType<T>,
+      serialized: unknown,
+      concreteRenderers: ConcreteRenderers<
+        T,
+        Flags,
+        CustomPresentationContexts,
+        ExtraContext
+      >,
+      types: Map<string, DispatchParsedType<T>>,
+    ) => ValueOrErrors<ListRenderer<T>, string>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/forms/domains/renderer/domains/lookup/state.d.ts

@@ -1,63 +1,128 @@
-import { ConcreteRenderers, DispatcherContext, DispatchInjectablesTypes, DispatchParsedType, LookupType, Renderer, ValueOrErrors } from "../../../../../../../../../../../../../main";
+import {
+  ConcreteRenderers,
+  DispatcherContext,
+  DispatchInjectablesTypes,
+  DispatchParsedType,
+  LookupType,
+  Renderer,
+  ValueOrErrors,
+} from "../../../../../../../../../../../../../main";
 import { Map } from "immutable";
-export type SerializedLookup<T> = {
-    kind: "lookupType-lookupRenderer";
-    renderer: string;
-    type: LookupType;
-} | {
-    kind: "lookupType-inlinedRenderer";
-    renderer: unknown;
-    type: LookupType;
-} | {
-    kind: "inlinedType-lookupRenderer";
-    renderer: string;
-    type: DispatchParsedType<T>;
-};
-export declare const SerializedLookup: {
-    Default: {
-        LookupTypeLookupRenderer: <T>(type: LookupType, renderer: string) => SerializedLookup<T>;
-        LookupTypeInlinedRenderer: <T>(type: LookupType, renderer: unknown) => SerializedLookup<T>;
-        InlinedTypeLookupRenderer: <T>(type: DispatchParsedType<T>, renderer: string) => SerializedLookup<T>;
+export type SerializedLookup<T> =
+  | {
+      kind: "lookupType-lookupRenderer";
+      renderer: string;
+      type: LookupType;
+    }
+  | {
+      kind: "lookupType-inlinedRenderer";
+      renderer: unknown;
+      type: LookupType;
+    }
+  | {
+      kind: "inlinedType-lookupRenderer";
+      renderer: string;
+      type: DispatchParsedType<T>;
     };
+export declare const SerializedLookup: {
+  Default: {
+    LookupTypeLookupRenderer: <T>(
+      type: LookupType,
+      renderer: string,
+    ) => SerializedLookup<T>;
+    LookupTypeInlinedRenderer: <T>(
+      type: LookupType,
+      renderer: unknown,
+    ) => SerializedLookup<T>;
+    InlinedTypeLookupRenderer: <T>(
+      type: DispatchParsedType<T>,
+      renderer: string,
+    ) => SerializedLookup<T>;
+  };
 };
-export type Lookup<T> = {
-    kind: "formLookup";
-    renderer: string;
-} | {
-    kind: "inlinedFormLookup";
-    renderer: Renderer<T>;
-};
-export declare const Lookup: {
-    Default: {
-        FormLookup: <T>(renderer: string) => Lookup<T>;
-        InlinedFormLookup: <T>(renderer: Renderer<T>) => Lookup<T>;
+export type Lookup<T> =
+  | {
+      kind: "formLookup";
+      renderer: string;
+    }
+  | {
+      kind: "inlinedFormLookup";
+      renderer: Renderer<T>;
     };
+export declare const Lookup: {
+  Default: {
+    FormLookup: <T>(renderer: string) => Lookup<T>;
+    InlinedFormLookup: <T>(renderer: Renderer<T>) => Lookup<T>;
+  };
 };
-export type LookupRenderer<T> = {
-    kind: "lookupType-lookupRenderer";
-    type: LookupType;
-    lookupRenderer: string;
-    tableApi: string | undefined;
-} | {
-    kind: "lookupType-inlinedRenderer";
-    inlinedRenderer: Renderer<T>;
-    type: LookupType;
-    tableApi: string | undefined;
-} | {
-    kind: "inlinedType-lookupRenderer";
-    lookupRenderer: string;
-    type: DispatchParsedType<T>;
-    tableApi: string | undefined;
-};
-export declare const LookupRenderer: {
-    Default: {
-        LookupTypeLookupRenderer: <T extends DispatchInjectablesTypes<T>>(type: LookupType, lookupRenderer: string, tableApi: string | undefined) => LookupRenderer<T>;
-        LookupTypeInlinedRenderer: <T extends DispatchInjectablesTypes<T>>(type: LookupType, inlinedRenderer: Renderer<T>, tableApi: string | undefined) => LookupRenderer<T>;
-        InlinedTypeLookupRenderer: <T extends DispatchInjectablesTypes<T>>(type: DispatchParsedType<T>, lookupRenderer: string, tableApi: string | undefined) => LookupRenderer<T>;
-    };
-    Operations: {
-        ResolveRenderer: <T extends DispatchInjectablesTypes<T>, Flags, CustomPresentationContexts, ExtraContext>(renderer: LookupRenderer<T>, forms: DispatcherContext<T, Flags, CustomPresentationContexts, ExtraContext>["forms"]) => ValueOrErrors<Renderer<T>, string>;
-        Deserialize: <T extends DispatchInjectablesTypes<T>, Flags, CustomPresentationContexts, ExtraContext>(serialized: SerializedLookup<T>, tableApi: string | undefined, concreteRenderers: ConcreteRenderers<T, Flags, CustomPresentationContexts, ExtraContext>, types: Map<string, DispatchParsedType<T>>) => ValueOrErrors<LookupRenderer<T>, string>;
+export type LookupRenderer<T> =
+  | {
+      kind: "lookupType-lookupRenderer";
+      type: LookupType;
+      lookupRenderer: string;
+      tableApi: string | undefined;
+    }
+  | {
+      kind: "lookupType-inlinedRenderer";
+      inlinedRenderer: Renderer<T>;
+      type: LookupType;
+      tableApi: string | undefined;
+    }
+  | {
+      kind: "inlinedType-lookupRenderer";
+      lookupRenderer: string;
+      type: DispatchParsedType<T>;
+      tableApi: string | undefined;
     };
+export declare const LookupRenderer: {
+  Default: {
+    LookupTypeLookupRenderer: <T extends DispatchInjectablesTypes<T>>(
+      type: LookupType,
+      lookupRenderer: string,
+      tableApi: string | undefined,
+    ) => LookupRenderer<T>;
+    LookupTypeInlinedRenderer: <T extends DispatchInjectablesTypes<T>>(
+      type: LookupType,
+      inlinedRenderer: Renderer<T>,
+      tableApi: string | undefined,
+    ) => LookupRenderer<T>;
+    InlinedTypeLookupRenderer: <T extends DispatchInjectablesTypes<T>>(
+      type: DispatchParsedType<T>,
+      lookupRenderer: string,
+      tableApi: string | undefined,
+    ) => LookupRenderer<T>;
+  };
+  Operations: {
+    ResolveRenderer: <
+      T extends DispatchInjectablesTypes<T>,
+      Flags,
+      CustomPresentationContexts,
+      ExtraContext,
+    >(
+      renderer: LookupRenderer<T>,
+      forms: DispatcherContext<
+        T,
+        Flags,
+        CustomPresentationContexts,
+        ExtraContext
+      >["forms"],
+    ) => ValueOrErrors<Renderer<T>, string>;
+    Deserialize: <
+      T extends DispatchInjectablesTypes<T>,
+      Flags,
+      CustomPresentationContexts,
+      ExtraContext,
+    >(
+      serialized: SerializedLookup<T>,
+      tableApi: string | undefined,
+      concreteRenderers: ConcreteRenderers<
+        T,
+        Flags,
+        CustomPresentationContexts,
+        ExtraContext
+      >,
+      types: Map<string, DispatchParsedType<T>>,
+    ) => ValueOrErrors<LookupRenderer<T>, string>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map