ballerina-core 1.0.243 → 1.0.244

package/bin/src/forms/domains/parser/domains/types/state.d.ts

@@ -7,206 +7,166 @@ export declare const isString: (_: any) => _ is string;
 export declare const isObject: (_: any) => _ is object;
 export declare const isGenericType: (_: any) => _ is GenericType;
 export declare const hasFun: (_: any) => _ is {
-  fun: string;
+    fun: string;
 };
 export declare const hasArgs: (_: any) => _ is {
-  args: Array<any>;
+    args: Array<any>;
 };
 export type CaseName = string;
 export type FieldName = string;
 export type TypeName = string;
 export type RawType<T> = {
-  fun?: string;
-  args?: Array<RawFieldType<T>> | Array<string>;
-  extends?: Array<TypeName>;
-  fields?: OrderedMap<FieldName, RawFieldType<T>>;
+    fun?: string;
+    args?: Array<RawFieldType<T>> | Array<string>;
+    extends?: Array<TypeName>;
+    fields?: OrderedMap<FieldName, RawFieldType<T>>;
 };
 export declare const RawType: {
-  isMaybeExtendedType: <T>(type: RawType<T>) => type is RawType<T> & {
-    extends: unknown;
-  };
-  isExtendedType: <T>(type: RawType<T>) => type is RawType<T> & {
-    extends: Array<TypeName>;
-  };
-  hasFields: <T>(type: RawType<T>) => type is {
-    fields: any;
-  };
-  isMaybeUnion: (_: any) => _ is RawUnionType;
-  isKeyOf: <T>(_: RawFieldType<T>) => _ is {
-    fun: "KeyOf";
-    args: Array<string>;
-  };
+    isMaybeExtendedType: <T>(type: RawType<T>) => type is RawType<T> & {
+        extends: unknown;
+    };
+    isExtendedType: <T>(type: RawType<T>) => type is RawType<T> & {
+        extends: Array<TypeName>;
+    };
+    hasFields: <T>(type: RawType<T>) => type is {
+        fields: any;
+    };
+    isMaybeUnion: (_: any) => _ is RawUnionType;
+    isKeyOf: <T>(_: RawFieldType<T>) => _ is {
+        fun: "KeyOf";
+        args: Array<string>;
+    };
 };
 export type RawApplicationType<T> = {
-  fun?: GenericType;
-  args?: Array<RawFieldType<T>>;
+    fun?: GenericType;
+    args?: Array<RawFieldType<T>>;
 };
 export type RawUnionCase = {
-  case?: string;
-  fields?: Object;
+    case?: string;
+    fields?: Object;
 };
 export type RawUnionType = {
-  fun?: "Union";
-  args?: Array<RawUnionCase>;
+    fun?: "Union";
+    args?: Array<RawUnionCase>;
 };
 export type RawOptionType = {
-  fun?: "Option";
-  args?: Array<RawFieldType<any>>;
+    fun?: "Option";
+    args?: Array<RawFieldType<any>>;
 };
 export type RawRecordType = {
-  fields?: object;
-};
-export type RawFieldType<T> =
-  | RawApplicationType<T>
-  | string
-  | Unit
-  | PrimitiveTypeName<T>
-  | RawUnionType
-  | RawRecordType
-  | RawUnionCase
-  | RawOptionType;
-export declare const RawFieldType: {
-  isMaybePrimitive: (_: any) => _ is string;
-  isPrimitive: <T>(
-    _: RawFieldType<T>,
-    injectedPrimitives: InjectedPrimitives<T> | undefined,
-  ) => _ is PrimitiveTypeName<T>;
-  isMaybeApplication: (_: any) => _ is Object;
-  isApplication: <T>(_: RawFieldType<T>) => _ is {
-    fun: GenericType;
-    args: Array<RawFieldType<T>>;
-  };
-  isMaybeLookup: (_: any) => _ is string;
-  isLookup: <T>(_: RawFieldType<T>) => _ is TypeName;
-  isList: <T>(_: RawFieldType<T>) => _ is {
-    fun: "List";
-    args: Array<RawFieldType<T>>;
-  };
-  isMap: <T>(_: RawFieldType<T>) => _ is {
-    fun: "Map";
-    args: Array<RawFieldType<T>>;
-  };
-  isSum: <T>(_: RawFieldType<T>) => _ is {
-    fun: "Sum";
-    args: Array<RawFieldType<T>>;
-  };
-  isSingleSelection: <T>(_: RawFieldType<T>) => _ is {
-    fun: "SingleSelection";
-    args: Array<RawFieldType<T>>;
-  };
-  isMultiSelection: <T>(_: RawFieldType<T>) => _ is {
-    fun: "MultiSelection";
-    args: Array<RawFieldType<T>>;
-  };
-  isUnionCase: <T>(_: RawFieldType<T>) => _ is {
-    caseName: string;
     fields?: object;
-  };
-  isUnion: <T>(_: RawFieldType<T>) => _ is {
-    fun: "Union";
-    args: Array<{
-      caseName: string;
-      fields?: object | string;
-    }>;
-  };
-  isTuple: <T>(_: RawFieldType<T>) => _ is {
-    fun: "Tuple";
-    args: Array<RawFieldType<T>>;
-  };
-  isRecord: <T>(_: RawFieldType<T>) => _ is {
-    fields: Object;
-  };
-  isOption: <T>(_: RawFieldType<T>) => _ is {
-    fun: "Option";
-    args: Array<RawFieldType<T>>;
-  };
-  isUnit: <T>(_: RawFieldType<T>) => _ is string;
-  isTable: <T>(_: RawFieldType<T>) => _ is {
-    fun: "Table";
-    args: Array<string>;
-  };
-};
-export type PrimitiveTypeName<T> =
-  | "unit"
-  | "string"
-  | "number"
-  | "maybeBoolean"
-  | "boolean"
-  | "Date"
-  | "base64File"
-  | "secret"
-  | keyof T
-  | "guid";
+};
+export type RawFieldType<T> = RawApplicationType<T> | string | Unit | PrimitiveTypeName<T> | RawUnionType | RawRecordType | RawUnionCase | RawOptionType;
+export declare const RawFieldType: {
+    isMaybePrimitive: (_: any) => _ is string;
+    isPrimitive: <T>(_: RawFieldType<T>, injectedPrimitives: InjectedPrimitives<T> | undefined) => _ is PrimitiveTypeName<T>;
+    isMaybeApplication: (_: any) => _ is Object;
+    isApplication: <T>(_: RawFieldType<T>) => _ is {
+        fun: GenericType;
+        args: Array<RawFieldType<T>>;
+    };
+    isMaybeLookup: (_: any) => _ is string;
+    isLookup: <T>(_: RawFieldType<T>) => _ is TypeName;
+    isList: <T>(_: RawFieldType<T>) => _ is {
+        fun: "List";
+        args: Array<RawFieldType<T>>;
+    };
+    isMap: <T>(_: RawFieldType<T>) => _ is {
+        fun: "Map";
+        args: Array<RawFieldType<T>>;
+    };
+    isSum: <T>(_: RawFieldType<T>) => _ is {
+        fun: "Sum";
+        args: Array<RawFieldType<T>>;
+    };
+    isSingleSelection: <T>(_: RawFieldType<T>) => _ is {
+        fun: "SingleSelection";
+        args: Array<RawFieldType<T>>;
+    };
+    isMultiSelection: <T>(_: RawFieldType<T>) => _ is {
+        fun: "MultiSelection";
+        args: Array<RawFieldType<T>>;
+    };
+    isUnionCase: <T>(_: RawFieldType<T>) => _ is {
+        caseName: string;
+        fields?: object;
+    };
+    isUnion: <T>(_: RawFieldType<T>) => _ is {
+        fun: "Union";
+        args: Array<{
+            caseName: string;
+            fields?: object | string;
+        }>;
+    };
+    isTuple: <T>(_: RawFieldType<T>) => _ is {
+        fun: "Tuple";
+        args: Array<RawFieldType<T>>;
+    };
+    isRecord: <T>(_: RawFieldType<T>) => _ is {
+        fields: Object;
+    };
+    isOption: <T>(_: RawFieldType<T>) => _ is {
+        fun: "Option";
+        args: Array<RawFieldType<T>>;
+    };
+    isUnit: <T>(_: RawFieldType<T>) => _ is string;
+    isTable: <T>(_: RawFieldType<T>) => _ is {
+        fun: "Table";
+        args: Array<string>;
+    };
+};
+export type PrimitiveTypeName<T> = "unit" | "string" | "number" | "maybeBoolean" | "boolean" | "Date" | "base64File" | "secret" | keyof T | "guid";
 export type RecordFields<T> = Map<FieldName, ParsedType<T>>;
 export type ParsedUnionCase<T> = {
-  kind: "unionCase";
-  name: CaseName;
-  fields: ParsedType<T>;
+    kind: "unionCase";
+    name: CaseName;
+    fields: ParsedType<T>;
 };
 export type ParsedApplicationType<T> = {
-  kind: "application";
-  value: GenericType;
-  args: Array<ParsedType<T>>;
+    kind: "application";
+    value: GenericType;
+    args: Array<ParsedType<T>>;
 };
 export type ParsedOptionType<T> = {
-  kind: "option";
-  value: ParsedType<T>;
+    kind: "option";
+    value: ParsedType<T>;
 };
 export type ParsedRecordType<T> = {
-  kind: "record";
-  value: TypeName;
-  fields: RecordFields<T>;
+    kind: "record";
+    value: TypeName;
+    fields: RecordFields<T>;
 };
 export type ParsedPrimitiveType<T> = {
-  kind: "primitive";
-  value: PrimitiveTypeName<T> | keyof T;
+    kind: "primitive";
+    value: PrimitiveTypeName<T> | keyof T;
 };
 export type ParsedTableType = {
-  kind: "table";
-  value: TypeName;
-  tableType: TypeName;
-};
-export type ParsedType<T> =
-  | ParsedOptionType<T>
-  | ParsedRecordType<T>
-  | ParsedPrimitiveType<T>
-  | {
-      kind: "lookup";
-      name: TypeName;
-    }
-  | ParsedApplicationType<T>
-  | ParsedTableType
-  | {
-      kind: "union";
-      args: Map<CaseName, ParsedUnionCase<T>>;
-    };
+    kind: "table";
+    value: TypeName;
+    tableType: TypeName;
+};
+export type ParsedType<T> = ParsedOptionType<T> | ParsedRecordType<T> | ParsedPrimitiveType<T> | {
+    kind: "lookup";
+    name: TypeName;
+} | ParsedApplicationType<T> | ParsedTableType | {
+    kind: "union";
+    args: Map<CaseName, ParsedUnionCase<T>>;
+};
 export declare const ParsedType: {
-  Default: {
-    unionCase: <T>(name: CaseName, fields: ParsedType<T>) => ParsedUnionCase<T>;
-    option: <T>(value: ParsedType<T>) => ParsedType<T>;
-    record: <T>(value: TypeName, fields: RecordFields<T>) => ParsedType<T>;
-    primitive: <T>(name: PrimitiveTypeName<T> | keyof T) => ParsedType<T>;
-    application: <T>(
-      value: GenericType,
-      args: Array<ParsedType<T>>,
-    ) => ParsedType<T>;
-    union: <T>(args: Map<CaseName, ParsedUnionCase<T>>) => ParsedType<T>;
-    lookup: <T>(name: string) => ParsedType<T>;
-    table: (value: TypeName, tableType: TypeName) => ParsedType<any>;
-  };
-  Operations: {
-    Equals: <T>(fst: ParsedType<T>, snd: ParsedType<T>) => boolean;
-    ParseRawKeyOf: <T>(
-      fieldName: TypeName,
-      rawFieldType: RawFieldType<T>,
-      types: Map<TypeName, ParsedType<T>>,
-    ) => ValueOrErrors<ParsedType<T>, string>;
-    ParseRawFieldType: <T>(
-      fieldName: TypeName,
-      rawFieldType: RawFieldType<T>,
-      types: Set<TypeName>,
-      injectedPrimitives?: InjectedPrimitives<T>,
-    ) => ValueOrErrors<ParsedType<T>, string>;
-  };
-};
-//# sourceMappingURL=state.d.ts.map
+    Default: {
+        unionCase: <T>(name: CaseName, fields: ParsedType<T>) => ParsedUnionCase<T>;
+        option: <T>(value: ParsedType<T>) => ParsedType<T>;
+        record: <T>(value: TypeName, fields: RecordFields<T>) => ParsedType<T>;
+        primitive: <T>(name: PrimitiveTypeName<T> | keyof T) => ParsedType<T>;
+        application: <T>(value: GenericType, args: Array<ParsedType<T>>) => ParsedType<T>;
+        union: <T>(args: Map<CaseName, ParsedUnionCase<T>>) => ParsedType<T>;
+        lookup: <T>(name: string) => ParsedType<T>;
+        table: (value: TypeName, tableType: TypeName) => ParsedType<any>;
+    };
+    Operations: {
+        Equals: <T>(fst: ParsedType<T>, snd: ParsedType<T>) => boolean;
+        ParseRawKeyOf: <T>(fieldName: TypeName, rawFieldType: RawFieldType<T>, types: Map<TypeName, ParsedType<T>>) => ValueOrErrors<ParsedType<T>, string>;
+        ParseRawFieldType: <T>(fieldName: TypeName, rawFieldType: RawFieldType<T>, types: Set<TypeName>, injectedPrimitives?: InjectedPrimitives<T>) => ValueOrErrors<ParsedType<T>, string>;
+    };
+};
+//# sourceMappingURL=state.d.ts.map

package/bin/src/forms/domains/parser/domains/validator/state.d.ts

@@ -1,181 +1,155 @@
 import { Map } from "immutable";
-import {
-  ApiConverters,
-  BuiltIns,
-  FieldName,
-  InjectedPrimitives,
-  ParsedType,
-  TypeName,
-  PredicateFormLayout,
-  PredicateComputedOrInlined,
-} from "../../../../../../main";
+import { ApiConverters, BuiltIns, FieldName, InjectedPrimitives, ParsedType, TypeName, PredicateFormLayout, PredicateComputedOrInlined } from "../../../../../../main";
 import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state";
 import { ParsedRenderer } from "../renderer/state";
 export type RawForm = {
-  type?: any;
-  fields?: any;
-  tabs?: any;
-  header?: any;
-  columns?: any;
-  renderer?: any;
-  visibleColumns?: any;
+    type?: any;
+    fields?: any;
+    tabs?: any;
+    header?: any;
+    columns?: any;
+    renderer?: any;
+    visibleColumns?: any;
 };
 export declare const RawForm: {
-  hasType: (_: any) => _ is {
-    type: any;
-  };
-  hasFields: (_: any) => _ is {
-    fields: any;
-  };
-  hasTabs: (_: any) => _ is {
-    tabs: any;
-  };
-  hasHeader: (_: any) => _ is {
-    header: any;
-  };
-  hasColumns: (_: any) => _ is {
-    columns: any;
-  };
-  hasRenderer: (_: any) => _ is {
-    renderer: any;
-  };
-  hasVisibleColumns: (_: any) => _ is {
-    visibleColumns: any;
-  };
+    hasType: (_: any) => _ is {
+        type: any;
+    };
+    hasFields: (_: any) => _ is {
+        fields: any;
+    };
+    hasTabs: (_: any) => _ is {
+        tabs: any;
+    };
+    hasHeader: (_: any) => _ is {
+        header: any;
+    };
+    hasColumns: (_: any) => _ is {
+        columns: any;
+    };
+    hasRenderer: (_: any) => _ is {
+        renderer: any;
+    };
+    hasVisibleColumns: (_: any) => _ is {
+        visibleColumns: any;
+    };
 };
-export type ParsedFormConfig<T> =
-  | ParsedRecordFormConfig<T>
-  | ParsedTableFormConfig<T>;
+export type ParsedFormConfig<T> = ParsedRecordFormConfig<T> | ParsedTableFormConfig<T>;
 export type ParsedRecordFormConfig<T> = {
-  kind: "recordForm";
-  name: string;
-  type: ParsedType<T>;
-  fields: Map<FieldName, ParsedRenderer<T>>;
-  tabs: PredicateFormLayout;
-  header?: string;
+    kind: "recordForm";
+    name: string;
+    type: ParsedType<T>;
+    fields: Map<FieldName, ParsedRenderer<T>>;
+    tabs: PredicateFormLayout;
+    header?: string;
 };
 export type ParsedTableFormConfig<T> = {
-  kind: "tableForm";
-  name: string;
-  type: ParsedType<T>;
-  columns: Map<FieldName, ParsedRenderer<T>>;
-  renderer: string;
-  visibleColumns: PredicateComputedOrInlined;
-  header?: string;
+    kind: "tableForm";
+    name: string;
+    type: ParsedType<T>;
+    columns: Map<FieldName, ParsedRenderer<T>>;
+    renderer: string;
+    visibleColumns: PredicateComputedOrInlined;
+    header?: string;
 };
 export type BaseLauncher = {
-  name: string;
-  form: string;
+    name: string;
+    form: string;
 };
 export type CreateLauncher = {
-  kind: "create";
-  api: string;
-  configApi: string;
+    kind: "create";
+    api: string;
+    configApi: string;
 } & BaseLauncher;
 export type EditLauncher = {
-  kind: "edit";
-  api: string;
-  configApi: string;
+    kind: "edit";
+    api: string;
+    configApi: string;
 } & BaseLauncher;
 export type PassthroughLauncher = {
-  kind: "passthrough";
-  configType: string;
+    kind: "passthrough";
+    configType: string;
 } & BaseLauncher;
 export type PassthroughTableLauncher = {
-  kind: "passthrough-table";
-  configType: string;
-  api: string;
+    kind: "passthrough-table";
+    configType: string;
+    api: string;
 } & BaseLauncher;
-export type Launcher =
-  | CreateLauncher
-  | EditLauncher
-  | PassthroughLauncher
-  | PassthroughTableLauncher;
+export type Launcher = CreateLauncher | EditLauncher | PassthroughLauncher | PassthroughTableLauncher;
 export type RawEntityApi = {
-  type?: any;
-  methods?: any;
+    type?: any;
+    methods?: any;
 };
 export type EntityApi = {
-  type: TypeName;
-  methods: {
-    create: boolean;
-    get: boolean;
-    update: boolean;
-    default: boolean;
-  };
+    type: TypeName;
+    methods: {
+        create: boolean;
+        get: boolean;
+        update: boolean;
+        default: boolean;
+    };
 };
 export type TableApi = {
-  type: TypeName;
+    type: TypeName;
 };
 export type GlobalConfigurationApi = {
-  type: TypeName;
-  methods: {
-    get: boolean;
-  };
+    type: TypeName;
+    methods: {
+        get: boolean;
+    };
 };
 export type RawFormJSON = {
-  types?: any;
-  apis?: any;
-  forms?: any;
-  launchers?: any;
+    types?: any;
+    apis?: any;
+    forms?: any;
+    launchers?: any;
 };
 export declare const RawFormJSON: {
-  hasTypes: (_: any) => _ is {
-    types: object;
-  };
-  hasForms: (_: any) => _ is {
-    forms: object;
-  };
-  hasApis: (_: any) => _ is {
-    apis: {
-      enumOptions?: object;
-      searchableStreams?: object;
-      entities?: {
-        globalConfiguration?: object;
-      };
-      globalConfiguration?: object;
-      tables?: object;
-    };
-  };
-  hasLaunchers: (_: any) => _ is {
-    launchers: any;
-  };
+    hasTypes: (_: any) => _ is {
+        types: object;
+    };
+    hasForms: (_: any) => _ is {
+        forms: object;
+    };
+    hasApis: (_: any) => _ is {
+        apis: {
+            enumOptions?: object;
+            searchableStreams?: object;
+            entities?: {
+                globalConfiguration?: object;
+            };
+            globalConfiguration?: object;
+            tables?: object;
+        };
+    };
+    hasLaunchers: (_: any) => _ is {
+        launchers: any;
+    };
 };
 export type ParsedFormJSON<T> = {
-  types: Map<TypeName, ParsedType<T>>;
-  apis: {
-    enums: Map<string, TypeName>;
-    streams: Map<string, TypeName>;
-    entities: Map<string, EntityApi>;
-    tables: Map<string, TableApi>;
-  };
-  forms: Map<string, ParsedFormConfig<T>>;
-  launchers: {
-    create: Map<string, CreateLauncher>;
-    edit: Map<string, EditLauncher>;
-    passthrough: Map<string, PassthroughLauncher>;
-    passthroughTable: Map<string, PassthroughTableLauncher>;
-  };
+    types: Map<TypeName, ParsedType<T>>;
+    apis: {
+        enums: Map<string, TypeName>;
+        streams: Map<string, TypeName>;
+        entities: Map<string, EntityApi>;
+        tables: Map<string, TableApi>;
+    };
+    forms: Map<string, ParsedFormConfig<T>>;
+    launchers: {
+        create: Map<string, CreateLauncher>;
+        edit: Map<string, EditLauncher>;
+        passthrough: Map<string, PassthroughLauncher>;
+        passthroughTable: Map<string, PassthroughTableLauncher>;
+    };
 };
 export type FormValidationError = string;
-export type FormConfigValidationAndParseResult<T> = ValueOrErrors<
-  ParsedFormJSON<T>,
-  FormValidationError
->;
+export type FormConfigValidationAndParseResult<T> = ValueOrErrors<ParsedFormJSON<T>, FormValidationError>;
 export declare const FormsConfig: {
-  Default: {
-    validateAndParseFormConfig: <
-      T extends {
-        [key in keyof T]: {
-          type: any;
-          state: any;
-        };
-      },
-    >(
-      builtIns: BuiltIns,
-      apiConverters: ApiConverters<T>,
-      injectedPrimitives?: InjectedPrimitives<T>,
-    ) => (fc: any) => FormConfigValidationAndParseResult<T>;
-  };
+    Default: {
+        validateAndParseFormConfig: <T extends { [key in keyof T]: {
+            type: any;
+            state: any;
+        }; }>(builtIns: BuiltIns, apiConverters: ApiConverters<T>, injectedPrimitives?: InjectedPrimitives<T>) => (fc: any) => FormConfigValidationAndParseResult<T>;
+    };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map