ballerina-core 1.0.256 → 1.0.257

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

@@ -7,166 +7,206 @@ 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;
+  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";
+  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>>;
-};
-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>;
+  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>>;
     };
-    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
+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