ballerina-core 1.0.213 → 1.0.215

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