@fncts/schema 0.0.5 → 0.0.7

package/_src/Schema/derivations.ts

@@ -0,0 +1,185 @@
+import type { TypeLiteral } from "@fncts/schema/AST";
+import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
+
+import { ownKeys } from "@fncts/schema/utils";
+
+/**
+ * @tsplus derive fncts.schema.Schema<_> 10
+ */
+export function deriveValidation<A extends Brand.Valid<any, any>>(
+  ...[base, brands]: Check<Brand.IsValidated<A>> extends Check.True
+    ? [
+        base: Schema<Brand.Unbranded<A>>,
+        brands: {
+          [K in keyof A[Brand.valid] & string]: Validation<A[Brand.valid][K], K>;
+        },
+      ]
+    : never
+): Schema<A> {
+  return Schema.fromAST(
+    AST.createValidation(
+      base.ast,
+      Vector.from(Object.values(brands)),
+      base.ast.annotations.annotate(ASTAnnotation.Brand, Vector.from(Object.values(brands))),
+    ),
+  );
+}
+
+/**
+ * @tsplus derive fncts.schema.Schema<_> 20
+ */
+export function deriveLiteral<A extends LiteralValue>(
+  ...[value]: Check<Check.IsLiteral<A> & Check.Not<Check.IsUnion<A>>> extends Check.True ? [value: A] : never
+): Schema<A> {
+  return Schema.literal(value);
+}
+
+type MaybeKeys<A> = { [K in keyof A]: A[K] extends Maybe<any> ? K : never }[keyof A];
+
+/**
+ * @tsplus derive fncts.schema.Schema<_> 20
+ */
+export function deriveStruct<A extends Record<string, any>>(
+  ...[requiredFields, optionalFields, maybeFields]: Check<Check.IsStruct<A>> extends Check.True
+    ? [
+        ...[
+          requiredFields: {
+            [k in Exclude<RequiredKeys<A>, MaybeKeys<A>>]: Schema<A[k]>;
+          },
+        ],
+        ...([OptionalKeys<A>] extends [never]
+          ? [optionalFields: {}]
+          : [
+              optionalFields: {
+                [k in OptionalKeys<A>]: Schema<NonNullable<A[k]>>;
+              },
+            ]),
+        ...([MaybeKeys<A>] extends [never]
+          ? []
+          : [
+              maybeFields: {
+                [k in MaybeKeys<A>]: [A[k]] extends [Maybe<infer _A>] ? Schema<_A> : never;
+              },
+            ]),
+      ]
+    : never
+): Schema<A> {
+  const maybeFieldsKeys: Vector<PropertyKey> = ownKeys(maybeFields);
+  let propertySignatures                     = ownKeys(requiredFields).map((key) =>
+    AST.createPropertySignature(key, requiredFields[key]!.ast, false, true),
+  );
+
+  if (optionalFields) {
+    propertySignatures = propertySignatures.concat(
+      ownKeys(optionalFields).map((key) => AST.createPropertySignature(key, optionalFields[key]!.ast, true, true)),
+    );
+  }
+
+  const struct = Schema.fromAST(AST.createTypeLiteral(propertySignatures, Vector.empty()));
+
+  if (maybeFieldsKeys.isEmpty()) {
+    return struct as Schema<any>;
+  }
+
+  propertySignatures = (struct.ast as TypeLiteral).propertySignatures;
+
+  const from = Schema.fromAST<any>(
+    AST.createTypeLiteral(
+      propertySignatures.concat(
+        maybeFieldsKeys.map((key) =>
+          AST.createPropertySignature(
+            key,
+            AST.createUnion(Vector(AST.undefinedKeyword, AST.createLiteral(null), maybeFields![key]!.ast)),
+            true,
+            true,
+          ),
+        ),
+      ),
+      Vector.empty(),
+    ),
+  );
+
+  const to = Schema.fromAST<any>(
+    AST.createTypeLiteral(
+      propertySignatures.concat(
+        maybeFieldsKeys.map((key) =>
+          AST.createPropertySignature(key, Schema.maybe(maybeFields![key]!).ast, true, true),
+        ),
+      ),
+      Vector.empty(),
+    ),
+  );
+
+  return from.transform(
+    to,
+    (input) => {
+      const output = { ...input };
+      for (const key of maybeFieldsKeys) {
+        output[key] = Maybe.fromNullable(input[key]);
+      }
+      return output;
+    },
+    (input) => {
+      const output = { ...input };
+      for (const key of maybeFieldsKeys) {
+        const value: Maybe<any> = input[key];
+        if (value.isNothing()) {
+          delete output[key];
+          continue;
+        }
+        output[key] = value.value;
+      }
+      return output;
+    },
+  );
+}
+
+/**
+ * @tsplus derive fncts.schema.Schema<_> 10
+ */
+export function deriveTuple<A extends ReadonlyArray<unknown>>(
+  ...[components]: Check<Check.IsTuple<A>> extends Check.True ? [components: { [K in keyof A]: Schema<A[K]> }] : never
+): Schema<A> {
+  return unsafeCoerce(Schema.tuple(...components));
+}
+
+/**
+ * @tsplus derive fncts.schema.Schema lazy
+ */
+export function deriveLazy<A>(f: (_: Schema<A>) => Schema<A>): Schema<A> {
+  let cached: AST | undefined;
+  const ast = AST.createLazy(() => {
+    if (!cached) {
+      cached = f(Schema.fromAST(ast)).ast;
+    }
+    return cached;
+  });
+  return Schema.fromAST(ast);
+}
+
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.Array]<_> 10
+ * @tsplus derive fncts.schema.Schema[fncts.ReadonlyArray]<_> 10
+ */
+export function deriveArray<A extends ReadonlyArray<any>>(
+  ...[element]: [A] extends [ReadonlyArray<infer _A>]
+    ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True
+      ? [element: Schema<_A>]
+      : never
+    : never
+): Schema<A> {
+  return Schema.array(element) as unknown as Schema<A>;
+}
+
+/**
+ * @tsplus derive fncts.schema.Schema<_> 15
+ */
+export function deriveRecord<A extends Record<string | symbol, any>>(
+  ...[keySchema, valueSchema]: [A] extends [Record<infer X, infer Y>]
+    ? Check<Check.Not<Check.IsUnion<A>> & Check.IsEqual<A, Record<X, Y>>> extends Check.True
+      ? [keySchema: Schema<X>, valueSchema: Schema<Y>]
+      : never
+    : never
+): Schema<A> {
+  return Schema.record(keySchema as Schema<string | symbol>, valueSchema) as Schema<A>;
+}

package/_src/Schema.ts

@@ -1,254 +1,14 @@
-import type { Brand, Validation } from "@fncts/base/data/Branded";
-import type { Schemable as S, SchemableKind } from "@fncts/schema/Schemable";
-import type { Literal } from "@fncts/typelevel/Any";
-
-export const SchemaVariance = Symbol.for("fncts.schema.Schema.Variance");
-export type SchemaVariance = typeof SchemaVariance;
-
-export const SchemaTypeId = Symbol.for("fncts.schema.Schema");
-export type SchemaTypeId = typeof SchemaTypeId;
-
-export const enum SchemaTag {
-  Unknown,
-  String,
-  Number,
-  Boolean,
-  BigInt,
-  Literal,
-  Nullable,
-  Struct,
-  Partial,
-  Array,
-  Record,
-  Tuple,
-  Lazy,
-  Validation,
-  Union,
-}
-
-export interface SchemaF extends HKT {
-  readonly type: Schema<this["A"]>;
-}
-
-export abstract class Schema<in out A> {
-  readonly [SchemaTypeId]: SchemaTypeId = SchemaTypeId;
-  declare [SchemaVariance]: {
-    _A: (_: A) => A;
-  };
-}
-
-export class UnknownSchema extends Schema<unknown> {
-  readonly _tag = SchemaTag.Unknown;
-}
-
-export class StringSchema extends Schema<string> {
-  readonly _tag = SchemaTag.String;
-}
-
-export class NumberSchema extends Schema<number> {
-  readonly _tag = SchemaTag.Number;
-}
-
-export class BooleanSchema extends Schema<boolean> {
-  readonly _tag = SchemaTag.Boolean;
-}
-
-export class BigIntSchema extends Schema<bigint> {
-  readonly _tag = SchemaTag.BigInt;
-}
-
-export class LiteralSchema<A extends Literal> extends Schema<A> {
-  readonly _tag = SchemaTag.Literal;
-  constructor(readonly value: A) {
-    super();
-  }
-}
-
-export class NullableSchema<A> extends Schema<A | null | undefined> {
-  readonly _tag = SchemaTag.Nullable;
-  constructor(readonly base: Schema<A>) {
-    super();
-  }
-}
-
-export class StructSchema<A extends Record<string, any>> extends Schema<A> {
-  readonly _tag = SchemaTag.Struct;
-  constructor(readonly fields: { [K in keyof A]: Schema<A[K]> }) {
-    super();
-  }
-}
-
-export class PartialSchema<A extends Record<string, any>> extends Schema<Partial<A>> {
-  readonly _tag = SchemaTag.Partial;
-  constructor(readonly fields: { [K in keyof A]: Schema<A[K]> }) {
-    super();
-  }
-}
-
-export class ArraySchema<A> extends Schema<ReadonlyArray<A>> {
-  readonly _tag = SchemaTag.Array;
-  constructor(readonly base: Schema<A>) {
-    super();
-  }
-}
-
-export class RecordSchema<A> extends Schema<Record<string, A>> {
-  readonly _tag = SchemaTag.Record;
-  constructor(readonly base: Schema<A>) {
-    super();
-  }
-}
-
-export class TupleSchema<A extends ReadonlyArray<any>> extends Schema<A> {
-  readonly _tag = SchemaTag.Tuple;
-  constructor(readonly components: { [K in keyof A]: Schema<A[K]> }) {
-    super();
-  }
-}
-
-export class LazySchema<A> extends Schema<A> {
-  readonly _tag = SchemaTag.Lazy;
-  constructor(readonly make: () => Schema<A>) {
-    super();
-  }
-}
-
-export class ValidationSchema<A, B extends ReadonlyArray<Validation<A, any>>> extends Schema<
-  A & { [K in keyof B]: B[K] extends Validation<any, infer S> ? Brand.Valid<A, S> : never }[number]
-> {
-  readonly _tag = SchemaTag.Validation;
-  constructor(readonly base: Schema<A>, readonly validations: readonly [...B]) {
-    super();
-  }
-}
-
-export class UnionSchema<A extends ReadonlyArray<any>> extends Schema<A[number]> {
-  readonly _tag = SchemaTag.Union;
-  constructor(readonly members: { [K in keyof A]: Schema<A[K]> }) {
-    super();
-  }
-}
-
-export const unknown: Schema<unknown> = new UnknownSchema();
-
-export const string: Schema<string> = new StringSchema();
-
-export const number: Schema<number> = new NumberSchema();
-
-export const boolean: Schema<boolean> = new BooleanSchema();
-
-export const bigint: Schema<bigint> = new BigIntSchema();
-
-export function literal<A extends Literal>(value: A): Schema<A> {
-  return new LiteralSchema(value);
-}
-
-export function nullable<A>(base: Schema<A>): Schema<A | null | undefined> {
-  return new NullableSchema(base);
-}
-
-export function struct<A extends Record<string, any>>(fields: { [K in keyof A]: Schema<A[K]> }): Schema<A> {
-  return new StructSchema(fields);
-}
-
-export function partial<A extends Record<string, any>>(fields: { [K in keyof A]: Schema<A[K]> }): Schema<Partial<A>> {
-  return new PartialSchema(fields);
-}
-
-export function array<A>(base: Schema<A>): Schema<ReadonlyArray<A>> {
-  return new ArraySchema(base);
-}
-
-export function record<A>(base: Schema<A>): Schema<Record<string, A>> {
-  return new RecordSchema(base);
-}
-
-export function tuple<A extends ReadonlyArray<any>>(...components: { [K in keyof A]: Schema<A[K]> }): Schema<A> {
-  return new TupleSchema(components).unsafeCoerce();
-}
-
-export function lazy<A>(make: () => Schema<A>): Schema<A> {
-  return new LazySchema(make);
-}
-
-export function validation<A, B extends ReadonlyArray<Validation<A, any>>>(...validations: B) {
-  return (
-    base: Schema<A>,
-  ): Schema<A & { [K in keyof B]: B[K] extends Validation<any, infer S> ? Brand.Valid<A, S> : never }[number]> =>
-    new ValidationSchema(base, validations).unsafeCoerce();
-}
-
-export function union<A extends ReadonlyArray<any>>(...members: { [K in keyof A]: Schema<A[K]> }): Schema<A[number]> {
-  return new UnionSchema(members);
-}
-
-export type Concrete =
-  | UnknownSchema
-  | StringSchema
-  | NumberSchema
-  | BooleanSchema
-  | BigIntSchema
-  | LiteralSchema<any>
-  | NullableSchema<any>
-  | StructSchema<Record<string, any>>
-  | PartialSchema<Record<string, any>>
-  | ArraySchema<any>
-  | RecordSchema<any>
-  | TupleSchema<ReadonlyArray<any>>
-  | LazySchema<any>
-  | ValidationSchema<any, ReadonlyArray<Validation<any, any>>>
-  | UnionSchema<ReadonlyArray<any>>;
-
-export function concrete(_: Schema<any>): asserts _ is Concrete {
-  //
-}
-
-function cacheThunk<A>(f: () => A): () => A {
-  let cached: A;
-  return () => {
-    if (!cached) {
-      cached = f();
-    }
-    return cached;
-  };
-}
-
-export function interpret<F extends HKT>(S: S<F>): <A>(schema: Schema<A>) => SchemableKind<F, A>;
-export function interpret<F extends HKT>(S: S<F>) {
-  return <A>(schema: Schema<A>): SchemableKind<F, any> => {
-    concrete(schema);
-    switch (schema._tag) {
-      case SchemaTag.Unknown:
-        return S.unknown;
-      case SchemaTag.String:
-        return S.string;
-      case SchemaTag.Number:
-        return S.number;
-      case SchemaTag.Boolean:
-        return S.boolean;
-      case SchemaTag.BigInt:
-        return S.bigint;
-      case SchemaTag.Literal:
-        return S.literal(schema.value);
-      case SchemaTag.Lazy:
-        const cached = cacheThunk(schema.make);
-        return S.lazy(() => interpret(S)(cached()));
-      case SchemaTag.Nullable:
-        return S.nullable(interpret(S)(schema.base));
-      case SchemaTag.Struct:
-        return S.struct(Dictionary.reverseGet(Dictionary.get(schema.fields).map(interpret(S))));
-      case SchemaTag.Partial:
-        return S.partial(Dictionary.reverseGet(Dictionary.get(schema.fields).map(interpret(S))));
-      case SchemaTag.Array:
-        return S.array(interpret(S)(schema.base));
-      case SchemaTag.Record:
-        return S.record(interpret(S)(schema.base));
-      case SchemaTag.Tuple:
-        return S.tuple(...schema.components.map(interpret(S)));
-      case SchemaTag.Validation:
-        return S.validation(...schema.validations)(interpret(S)(schema.base));
-      case SchemaTag.Union:
-        return S.union(schema.members.map(interpret(S)), schema);
-    }
-  };
-}
+// codegen:start { preset: barrel, include: ./Schema/*.ts }
+export * from "./Schema/api.js";
+export * from "./Schema/definition.js";
+export * from "./Schema/derivations.js";
+// codegen:end
+
+// codegen:start { preset: barrel, include: ./Schema/api/*.ts }
+export * from "./Schema/api/conc.js";
+export * from "./Schema/api/either.js";
+export * from "./Schema/api/hashMap.js";
+export * from "./Schema/api/immutableArray.js";
+export * from "./Schema/api/list.js";
+export * from "./Schema/api/maybe.js";
+// codegen:end

package/_src/global.ts

@@ -6,3 +6,56 @@ import type {} from "@fncts/base/global";
  * @tsplus global
  */
 import type { HKT } from "@fncts/typelevel/HKT";
+
+/**
+ * @tsplus global
+ */
+import { Brand, Validation } from "@fncts/base/data/Branded";
+/**
+ * @tsplus global
+ */
+import { FIO, IO, UIO } from "@fncts/io/IO";
+/**
+ * @tsplus global
+ */
+import { Layer } from "@fncts/io/Layer";
+/**
+ * @tsplus global
+ */
+import { Stream } from "@fncts/io/Stream";
+/**
+ * @tsplus global
+ */
+import { AST, LiteralValue } from "@fncts/schema/AST";
+/**
+ * @tsplus global
+ */
+import { ASTAnnotation } from "@fncts/schema/ASTAnnotation";
+/**
+ * @tsplus global
+ */
+import { ASTAnnotationMap } from "@fncts/schema/ASTAnnotationMap";
+/**
+ * @tsplus global
+ */
+import { ParseError } from "@fncts/schema/ParseError";
+/**
+ * @tsplus global
+ */
+import { Parser } from "@fncts/schema/Parser/definition";
+/**
+ * @tsplus global
+ */
+import { ParseResult } from "@fncts/schema/ParseResult";
+/**
+ * @tsplus global
+ */
+import { OptionalSchema, Schema } from "@fncts/schema/Schema/definition";
+/**
+ * @tsplus global
+ */
+import { Gen } from "@fncts/test/control/Gen";
+/**
+ * @tsplus global
+ */
+import { Check } from "@fncts/typelevel";

package/_src/utils.ts

@@ -0,0 +1,48 @@
+import type { IndexSignature, TemplateLiteral } from "./AST";
+
+import { ASTTag } from "./AST.js";
+
+export function memoize<A, B>(f: (a: A) => B): (a: A) => B {
+  const cache = new Map();
+  return (a) => {
+    if (!cache.has(a)) {
+      const b = f(a);
+      cache.set(a, b);
+      return b;
+    }
+    return cache.get(a);
+  };
+}
+
+export function ownKeys(o: object | undefined): Vector<PropertyKey> {
+  return o ? Vector.from(Reflect.ownKeys(o)) : Vector.empty();
+}
+
+export function getTemplateLiteralRegex(ast: TemplateLiteral): RegExp {
+  let pattern = `^${ast.head}`;
+  for (const span of ast.spans) {
+    if (span.type.isStringKeyword()) {
+      pattern += ".*";
+    } else if (span.type.isNumberKeyword()) {
+      pattern += "-?\\d+(\\.\\d+)?";
+    }
+    pattern += span.literal;
+  }
+  pattern += "$";
+  return new RegExp(pattern);
+}
+
+export function getKeysForIndexSignature(
+  input: { readonly [x: PropertyKey]: unknown },
+  parameter: IndexSignature["parameter"],
+): Vector<string> | Vector<symbol> {
+  switch (parameter._tag) {
+    case ASTTag.StringKeyword:
+    case ASTTag.TemplateLiteral:
+      return Vector.from(Object.keys(input));
+    case ASTTag.SymbolKeyword:
+      return Vector.from(Object.getOwnPropertySymbols(input));
+    case ASTTag.Refinement:
+      return getKeysForIndexSignature(input, parameter.from as any);
+  }
+}

package/global.d.ts

@@ -6,4 +6,56 @@ import type {} from "@fncts/base/global";
  * @tsplus global
  */
 import type { HKT } from "@fncts/typelevel/HKT";
+/**
+ * @tsplus global
+ */
+import { Brand, Validation } from "@fncts/base/data/Branded";
+/**
+ * @tsplus global
+ */
+import { FIO, IO, UIO } from "@fncts/io/IO";
+/**
+ * @tsplus global
+ */
+import { Layer } from "@fncts/io/Layer";
+/**
+ * @tsplus global
+ */
+import { Stream } from "@fncts/io/Stream";
+/**
+ * @tsplus global
+ */
+import { AST, LiteralValue } from "@fncts/schema/AST";
+/**
+ * @tsplus global
+ */
+import { ASTAnnotation } from "@fncts/schema/ASTAnnotation";
+/**
+ * @tsplus global
+ */
+import { ASTAnnotationMap } from "@fncts/schema/ASTAnnotationMap";
+/**
+ * @tsplus global
+ */
+import { ParseError } from "@fncts/schema/ParseError";
+/**
+ * @tsplus global
+ */
+import { Parser } from "@fncts/schema/Parser/definition";
+/**
+ * @tsplus global
+ */
+import { ParseResult } from "@fncts/schema/ParseResult";
+/**
+ * @tsplus global
+ */
+import { OptionalSchema, Schema } from "@fncts/schema/Schema/definition";
+/**
+ * @tsplus global
+ */
+import { Gen } from "@fncts/test/control/Gen";
+/**
+ * @tsplus global
+ */
+import { Check } from "@fncts/typelevel";
 export {};

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@fncts/schema",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "dependencies": {
-    "@fncts/base": "0.0.26",
+    "@fncts/base": "0.0.28",
     "@fncts/typelevel": "0.0.15"
   },
   "exports": {

package/utils.d.ts

@@ -0,0 +1,8 @@
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import type { IndexSignature, TemplateLiteral } from "./AST";
+export declare function memoize<A, B>(f: (a: A) => B): (a: A) => B;
+export declare function ownKeys(o: object | undefined): Vector<PropertyKey>;
+export declare function getTemplateLiteralRegex(ast: TemplateLiteral): RegExp;
+export declare function getKeysForIndexSignature(input: {
+    readonly [x: PropertyKey]: unknown;
+}, parameter: IndexSignature["parameter"]): Vector<string> | Vector<symbol>;

package/Decoder.d.ts

@@ -1,3 +0,0 @@
-import type { DecoderF } from "@fncts/base/data/Decoder";
-import type { Schemable as S } from "@fncts/schema/Schemable";
-export declare const Schemable: S<DecoderF>;

package/Encoder.d.ts

@@ -1,4 +0,0 @@
-import { Encoder } from "@fncts/base/data/Encoder/definition";
-import type { EncoderF } from "@fncts/base/data/Encoder";
-import type { Schemable as S } from "@fncts/schema/Schemable";
-export declare const Schemable: S<EncoderF>;

package/Guard.d.ts

@@ -1,3 +0,0 @@
-import type { GuardF } from "@fncts/base/data/Guard";
-import type { Schemable as S } from "@fncts/schema/Schemable";
-export declare const Schemable: S<GuardF>;

package/Schemable.d.ts

@@ -1,39 +0,0 @@
-import { HKT } from "@fncts/typelevel/HKT";
-import type { Brand, Validation } from "@fncts/base/data/Branded";
-import type { UnionSchema } from "@fncts/schema/Schema";
-import type { Literal } from "@fncts/typelevel/Any";
-export type SchemableKind<F extends HKT, A> = F extends {
-    readonly type: unknown;
-} ? (F & {
-    readonly A: A;
-})["type"] : {
-    readonly _F: F;
-    readonly _A: A;
-};
-export interface Schemable<F extends HKT> {
-    readonly unknown: SchemableKind<F, unknown>;
-    readonly string: SchemableKind<F, string>;
-    readonly number: SchemableKind<F, number>;
-    readonly boolean: SchemableKind<F, boolean>;
-    readonly bigint: SchemableKind<F, bigint>;
-    readonly literal: <A extends Literal>(literal: A) => SchemableKind<F, A>;
-    readonly nullable: <A>(or: SchemableKind<F, A>) => SchemableKind<F, A | null | undefined>;
-    readonly struct: <P extends Record<string, any>>(properties: {
-        [K in keyof P]: SchemableKind<F, P[K]>;
-    }) => SchemableKind<F, P>;
-    readonly partial: <P extends Record<string, any>>(properties: {
-        [K in keyof P]: SchemableKind<F, P[K]>;
-    }) => SchemableKind<F, Partial<P>>;
-    readonly array: <A>(item: SchemableKind<F, A>) => SchemableKind<F, ReadonlyArray<A>>;
-    readonly record: <A>(codomain: SchemableKind<F, A>) => SchemableKind<F, Record<string, A>>;
-    readonly tuple: <C extends ReadonlyArray<any>>(...components: {
-        [K in keyof C]: SchemableKind<F, C[K]>;
-    }) => SchemableKind<F, C>;
-    readonly lazy: <A>(f: () => SchemableKind<F, A>) => SchemableKind<F, A>;
-    readonly validation: <A, B extends ReadonlyArray<Validation<A, any>>>(...validations: B) => (base: SchemableKind<F, A>) => SchemableKind<F, A & {
-        [K in keyof B]: B[K] extends Validation<any, infer S> ? Brand.Valid<A, S> : never;
-    }[number]>;
-    readonly union: <A extends ReadonlyArray<any>>(members: {
-        [K in keyof A]: SchemableKind<F, A[K]>;
-    }, schema: UnionSchema<A>) => SchemableKind<F, A[number]>;
-}