rado 0.4.9 → 1.0.0-preview.0

package/dist/core/expr/Conditions.js

@@ -0,0 +1,137 @@
+import { sql } from "../Sql.ts";
+import { input } from "./Input.ts";
+function eq(left, right) {
+  return sql`${input(left)} = ${input(right)}`;
+}
+function ne(left, right) {
+  return sql`${input(left)} <> ${input(right)}`;
+}
+function and(...conditions) {
+  if (conditions.length === 0)
+    return sql`true`;
+  if (conditions.length === 1)
+    return input(conditions[0]);
+  return sql`(${sql.join(conditions.map(input), sql.unsafe(" and "))})`;
+}
+function or(...conditions) {
+  if (conditions.length === 0)
+    return sql`true`;
+  if (conditions.length === 1)
+    return input(conditions[0]);
+  return sql`(${sql.join(conditions.map(input), sql.unsafe(" or "))})`;
+}
+function not(condition) {
+  return sql`not ${input(condition)}`;
+}
+function gt(left, right) {
+  return sql`${input(left)} > ${input(right)}`;
+}
+function gte(left, right) {
+  return sql`${input(left)} >= ${input(right)}`;
+}
+function lt(left, right) {
+  return sql`${input(left)} < ${input(right)}`;
+}
+function lte(left, right) {
+  return sql`${input(left)} <= ${input(right)}`;
+}
+function inArray(left, right) {
+  if (Array.isArray(right)) {
+    if (right.length === 0)
+      return sql`false`;
+    return sql`${input(left)} in (${sql.join(
+      right.map(input),
+      sql.unsafe(", ")
+    )})`;
+  }
+  return sql`${input(left)} in ${input(right)}`;
+}
+function notInArray(left, right) {
+  if (Array.isArray(right)) {
+    if (right.length === 0)
+      return sql`true`;
+    return sql`${input(left)} not in (${sql.join(right.map(input), sql`, `)})`;
+  }
+  return sql`${input(left)} not in ${input(right)}`;
+}
+function isNull(value) {
+  return sql`${input(value)} is null`;
+}
+function isNotNull(value) {
+  return sql`${input(value)} is not null`;
+}
+function between(value, left, right) {
+  return sql`${input(value)} between ${input(left)} and ${input(right)}`;
+}
+function notBetween(value, left, right) {
+  return sql`${input(value)} not between ${input(left)} and ${input(right)}`;
+}
+function like(left, pattern) {
+  return sql`${input(left)} like ${input(pattern)}`;
+}
+function notLike(value, pattern) {
+  return sql`${input(value)} not like ${input(pattern)}`;
+}
+function ilike(value, pattern) {
+  return sql`${input(value)} ilike ${input(pattern)}`;
+}
+function notILike(value, pattern) {
+  return sql`${input(value)} not ilike ${input(pattern)}`;
+}
+function arrayContains(left, right) {
+  return sql`${input(left)} @> ${input(right)}`;
+}
+function arrayContained(left, right) {
+  return sql`${input(left)} <@ ${input(right)}`;
+}
+function arrayOverlaps(left, right) {
+  return sql`${input(left)} && ${input(right)}`;
+}
+function asc(input2) {
+  return sql`${input2} asc`;
+}
+function desc(input2) {
+  return sql`${input2} desc`;
+}
+function distinct(input2) {
+  return sql`distinct ${input2}`;
+}
+const INDEX_PROPERTY = /^\d+$/;
+function jsonExpr(e) {
+  return new Proxy(e, {
+    get(target, prop) {
+      if (typeof prop !== "string")
+        return Reflect.get(target, prop);
+      const isNumber = INDEX_PROPERTY.test(prop);
+      return jsonExpr(sql`${target}`.jsonPath([isNumber ? Number(prop) : prop]));
+    }
+  });
+}
+export {
+  and,
+  arrayContained,
+  arrayContains,
+  arrayOverlaps,
+  asc,
+  between,
+  desc,
+  distinct,
+  eq,
+  gt,
+  gte,
+  ilike,
+  inArray,
+  isNotNull,
+  isNull,
+  jsonExpr,
+  like,
+  lt,
+  lte,
+  ne,
+  not,
+  notBetween,
+  notILike,
+  notInArray,
+  notLike,
+  or
+};

package/dist/core/expr/Field.d.ts

@@ -0,0 +1,14 @@
+import { internalField, internalSql, type HasSql } from '../Internal.ts';
+import { type Sql } from '../Sql.ts';
+export interface FieldData {
+    targetName: string;
+    fieldName: string;
+}
+export declare class Field<Value = unknown, Table extends string = string> implements HasSql<Value> {
+    private brand;
+    readonly [internalField]: FieldData;
+    readonly [internalSql]: Sql<Value>;
+    constructor(targetName: string, fieldName: string, options?: {
+        mapFromDriverValue?(value: unknown): Value;
+    });
+}

package/dist/core/expr/Field.js

@@ -0,0 +1,15 @@
+import { internalField, internalSql } from "../Internal.ts";
+import { sql } from "../Sql.ts";
+class Field {
+  [internalField];
+  [internalSql];
+  constructor(targetName, fieldName, options = {}) {
+    const field = { targetName, fieldName };
+    this[internalField] = field;
+    const expr = sql.field(field).as(fieldName).mapWith(options);
+    this[internalSql] = expr;
+  }
+}
+export {
+  Field
+};

package/dist/core/expr/Functions.d.ts

@@ -0,0 +1,6 @@
+import { type Sql } from '../Sql.ts';
+import { type Input } from './Input.ts';
+export declare const Functions: Functions;
+export type Functions = {
+    [key: string]: (...args: Array<Input<any>>) => Sql<any>;
+};

package/dist/core/expr/Functions.js

@@ -0,0 +1,11 @@
+import { sql } from "../Sql.ts";
+import { input } from "./Input.ts";
+function get(target, method) {
+  return target[method] ??= (...args) => {
+    return sql`${sql.identifier(method)}(${sql.join(args.map(input), sql`, `)})`;
+  };
+}
+const Functions = new Proxy(/* @__PURE__ */ Object.create(null), { get });
+export {
+  Functions
+};

package/dist/core/expr/Input.d.ts

@@ -0,0 +1,3 @@
+import { type HasSql } from '../Internal.ts';
+export type Input<T = unknown> = HasSql<T> | T;
+export declare function input<T>(value: Input<T>): HasSql<T>;

package/dist/core/expr/Input.js

@@ -0,0 +1,14 @@
+import { getSql, getTable, hasSql, hasTable } from "../Internal.ts";
+import { sql } from "../Sql.ts";
+function input(value) {
+  if (typeof value !== "object" || value === null)
+    return sql.value(value);
+  if (hasTable(value))
+    return sql.identifier(getTable(value).name);
+  if (hasSql(value))
+    return getSql(value);
+  return sql.value(value);
+}
+export {
+  input
+};

package/dist/core/query/CreateTable.d.ts

@@ -0,0 +1,13 @@
+import { internalData, internalQuery, type HasTable } from '../Internal.ts';
+import type { QueryMeta } from '../MetaData.ts';
+import { Query, type QueryData } from '../Query.ts';
+export interface CreateData<Meta extends QueryMeta> extends QueryData<Meta> {
+    table: HasTable;
+    ifNotExists?: boolean;
+}
+export declare class Create<Meta extends QueryMeta = QueryMeta> extends Query<void, Meta> {
+    readonly [internalData]: CreateData<Meta>;
+    constructor(data: CreateData<Meta>);
+    ifNotExists(): Create<Meta>;
+    get [internalQuery](): import("../Sql.ts").Sql<unknown>;
+}

package/dist/core/query/CreateTable.js

@@ -0,0 +1,23 @@
+import {
+  getData,
+  internalData,
+  internalQuery
+} from "../Internal.ts";
+import { Query } from "../Query.ts";
+import { sql } from "../Sql.ts";
+class Create extends Query {
+  [internalData];
+  constructor(data) {
+    super(data);
+    this[internalData] = data;
+  }
+  ifNotExists() {
+    return new Create({ ...getData(this), ifNotExists: true });
+  }
+  get [internalQuery]() {
+    return sql.chunk("emitCreateTable", this);
+  }
+}
+export {
+  Create
+};

package/dist/core/query/Delete.d.ts

@@ -0,0 +1,19 @@
+import { internalData, internalQuery, internalSelection, type HasSql, type HasTable } from '../Internal.ts';
+import type { QueryMeta } from '../MetaData.ts';
+import { Query, QueryData } from '../Query.ts';
+import { type Selection, type SelectionInput, type SelectionRow } from '../Selection.ts';
+export declare class DeleteData<Meta extends QueryMeta = QueryMeta> extends QueryData<Meta> {
+    from: HasTable;
+    where?: HasSql;
+    returning?: Selection;
+}
+export declare class Delete<Result, Meta extends QueryMeta = QueryMeta> extends Query<Result, Meta> {
+    readonly [internalData]: DeleteData<Meta>;
+    readonly [internalSelection]?: Selection;
+    constructor(data: DeleteData<Meta>);
+    get [internalQuery](): import("../Sql.ts").Sql<unknown>;
+}
+export declare class DeleteFrom<Meta extends QueryMeta> extends Delete<void, Meta> {
+    where(condition: HasSql<boolean>): DeleteFrom<Meta>;
+    returning<Input extends SelectionInput>(returning: Input): Delete<SelectionRow<Input>, Meta>;
+}

package/dist/core/query/Delete.js

@@ -0,0 +1,44 @@
+import {
+  getData,
+  internalData,
+  internalQuery,
+  internalSelection
+} from "../Internal.ts";
+import { Query, QueryData } from "../Query.ts";
+import {
+  selection
+} from "../Selection.ts";
+import { sql } from "../Sql.ts";
+class DeleteData extends QueryData {
+  from;
+  where;
+  returning;
+}
+class Delete extends Query {
+  [internalData];
+  constructor(data) {
+    super(data);
+    this[internalData] = data;
+    if (data.returning)
+      this[internalSelection] = data.returning;
+  }
+  get [internalQuery]() {
+    return sql.chunk("emitDelete", this);
+  }
+}
+class DeleteFrom extends Delete {
+  where(condition) {
+    return new DeleteFrom({ ...getData(this), where: condition });
+  }
+  returning(returning) {
+    return new Delete({
+      ...getData(this),
+      returning: selection(returning)
+    });
+  }
+}
+export {
+  Delete,
+  DeleteData,
+  DeleteFrom
+};

package/dist/core/query/DropTable.d.ts

@@ -0,0 +1,13 @@
+import { internalData, internalQuery, type HasTable } from '../Internal.ts';
+import type { QueryMeta } from '../MetaData.ts';
+import { Query, type QueryData } from '../Query.ts';
+export interface DropData<Meta extends QueryMeta> extends QueryData<Meta> {
+    table: HasTable;
+    ifExists?: boolean;
+}
+export declare class Drop<Meta extends QueryMeta = QueryMeta> extends Query<void, Meta> {
+    readonly [internalData]: DropData<Meta>;
+    constructor(data: DropData<Meta>);
+    ifExists(): Drop<Meta>;
+    get [internalQuery](): import("../Sql.ts").Sql<unknown>;
+}

package/dist/core/query/DropTable.js

@@ -0,0 +1,23 @@
+import {
+  getData,
+  internalData,
+  internalQuery
+} from "../Internal.ts";
+import { Query } from "../Query.ts";
+import { sql } from "../Sql.ts";
+class Drop extends Query {
+  [internalData];
+  constructor(data) {
+    super(data);
+    this[internalData] = data;
+  }
+  ifExists() {
+    return new Drop({ ...getData(this), ifExists: true });
+  }
+  get [internalQuery]() {
+    return sql.chunk("emitDrop", this);
+  }
+}
+export {
+  Drop
+};

package/dist/core/query/Insert.d.ts

@@ -0,0 +1,43 @@
+import { internalData, internalQuery, internalSelection, type HasSql, type HasTable } from '../Internal.ts';
+import type { IsPostgres, QueryMeta } from '../MetaData.ts';
+import { Query, QueryData } from '../Query.ts';
+import { type Selection, type SelectionInput, type SelectionRow } from '../Selection.ts';
+import type { TableDefinition, TableInsert, TableRow, TableUpdate } from '../Table.ts';
+declare class InsertIntoData<Meta extends QueryMeta> extends QueryData<Meta> {
+    into: HasTable;
+    values?: HasSql;
+}
+export declare class InsertData<Meta extends QueryMeta> extends InsertIntoData<Meta> {
+    returning?: Selection;
+    onConflict?: HasSql;
+}
+export declare class Insert<Result, Meta extends QueryMeta = QueryMeta> extends Query<Result, Meta> {
+    readonly [internalData]: InsertData<Meta>;
+    readonly [internalSelection]?: Selection;
+    constructor(data: InsertData<Meta>);
+    get [internalQuery](): import("../Sql.ts").Sql<unknown>;
+}
+declare class InsertCanReturn<Definition extends TableDefinition, Meta extends QueryMeta> extends Insert<void, Meta> {
+    returning(): Insert<TableRow<Definition>, Meta>;
+    returning<Input extends SelectionInput>(returning: Input): Insert<SelectionRow<Input>, Meta>;
+}
+export interface OnConflict {
+    target: HasSql | Array<HasSql>;
+    targetWhere?: HasSql<boolean>;
+}
+export interface OnConflictUpdate<Definition extends TableDefinition> extends OnConflict {
+    set: TableUpdate<Definition>;
+    setWhere?: HasSql<boolean>;
+}
+declare class InsertCanConflict<Definition extends TableDefinition, Meta extends QueryMeta> extends InsertCanReturn<Definition, Meta> {
+    #private;
+    onConflictDoNothing(this: InsertCanConflict<Definition, IsPostgres>, onConflict?: OnConflict): InsertCanReturn<Definition, Meta>;
+    onConflictDoUpdate(this: InsertCanConflict<Definition, IsPostgres>, onConflict: OnConflictUpdate<Definition>): InsertCanReturn<Definition, Meta>;
+}
+export declare class InsertInto<Definition extends TableDefinition, Meta extends QueryMeta> {
+    [internalData]: InsertData<Meta>;
+    constructor(data: InsertData<Meta>);
+    values(value: TableInsert<Definition>): InsertCanConflict<Definition, Meta>;
+    values(values: Array<TableInsert<Definition>>): InsertCanConflict<Definition, Meta>;
+}
+export {};

package/dist/core/query/Insert.js

@@ -0,0 +1,111 @@
+import {
+  getColumn,
+  getData,
+  getTable,
+  internalData,
+  internalQuery,
+  internalSelection
+} from "../Internal.ts";
+import { Query, QueryData } from "../Query.ts";
+import {
+  selection
+} from "../Selection.ts";
+import { sql } from "../Sql.ts";
+import { input } from "../expr/Input.ts";
+class InsertIntoData extends QueryData {
+  into;
+  values;
+}
+class InsertData extends InsertIntoData {
+  returning;
+  onConflict;
+}
+class Insert extends Query {
+  [internalData];
+  constructor(data) {
+    super(data);
+    this[internalData] = data;
+    if (data.returning)
+      this[internalSelection] = data.returning;
+  }
+  get [internalQuery]() {
+    return sql.chunk("emitInsert", this);
+  }
+}
+class InsertCanReturn extends Insert {
+  returning(returning) {
+    const data = getData(this);
+    return new Insert({
+      ...data,
+      returning: selection(returning ?? data.into)
+    });
+  }
+}
+class InsertCanConflict extends InsertCanReturn {
+  onConflictDoNothing(onConflict) {
+    return this.#onConflict(onConflict ?? {});
+  }
+  onConflictDoUpdate(onConflict) {
+    return this.#onConflict(onConflict);
+  }
+  #onConflict({
+    target,
+    targetWhere,
+    set,
+    setWhere
+  }) {
+    const update = set && sql.join(
+      Object.entries(set).map(
+        ([key, value]) => sql`${sql.identifier(key)} = ${input(value)}`
+      ),
+      sql`, `
+    );
+    return new InsertCanReturn({
+      ...getData(this),
+      onConflict: sql.join([
+        target && sql`(${Array.isArray(target) ? sql.join(target, sql`, `) : target})`,
+        targetWhere && sql`where ${targetWhere}`,
+        update ? sql.join([
+          sql`do update set ${update}`,
+          setWhere && sql`where ${setWhere}`
+        ]) : sql`do nothing`
+      ])
+    });
+  }
+}
+class InsertInto {
+  [internalData];
+  constructor(data) {
+    this[internalData] = data;
+  }
+  values(insert) {
+    const { into } = getData(this);
+    const rows = Array.isArray(insert) ? insert : [insert];
+    const table = getTable(into);
+    const values = sql.join(
+      rows.map((row) => {
+        return sql`(${sql.join(
+          Object.entries(table.columns).map(([key, column]) => {
+            const value = row[key];
+            const { defaultValue, notNull, mapToDriverValue } = getColumn(column);
+            if (value !== void 0)
+              return input(mapToDriverValue ? mapToDriverValue(value) : value);
+            if (defaultValue)
+              return defaultValue();
+            if (notNull)
+              throw new Error(`Column "${key}" is not nullable`);
+            return sql.chunk("emitDefaultValue", void 0);
+          }),
+          sql`, `
+        )})`;
+      }),
+      sql`, `
+    );
+    return new InsertCanConflict({ ...getData(this), values });
+  }
+}
+export {
+  Insert,
+  InsertData,
+  InsertInto
+};

package/dist/core/query/Select.d.ts

@@ -0,0 +1,93 @@
+import { internalData, internalQuery, internalSelection, type HasSelection, type HasSql, type HasTable, type HasTarget } from '../Internal.ts';
+import type { IsMysql, IsPostgres, QueryMeta } from '../MetaData.ts';
+import { Query, QueryData } from '../Query.ts';
+import { type IsNullable, type MakeNullable, type SelectionInput, type SelectionRecord, type SelectionRow } from '../Selection.ts';
+import type { Table, TableDefinition, TableFields } from '../Table.ts';
+import type { Expand } from '../Types.ts';
+import type { Field } from '../expr/Field.ts';
+import { type Input as UserInput } from '../expr/Input.ts';
+import { Union } from './Union.ts';
+export type SelectionType = 'selection' | 'allFrom' | 'joinTables';
+export declare class SelectData<Meta extends QueryMeta> extends QueryData<Meta> {
+    select: {
+        type: SelectionType;
+        tables: Array<string>;
+        nullable: Array<string>;
+        input?: SelectionInput;
+    };
+    distinct?: boolean;
+    distinctOn?: Array<HasSql>;
+    from?: HasSql;
+    subject?: HasSql;
+    where?: HasSql;
+    groupBy?: HasSql;
+    having?: HasSql;
+    orderBy?: HasSql;
+    limit?: HasSql;
+    offset?: HasSql;
+}
+export declare class Select<Input, Meta extends QueryMeta = QueryMeta> extends Query<SelectionRow<Input>, Meta> implements HasSelection, SelectBase<Input, Meta> {
+    #private;
+    readonly [internalData]: SelectData<Meta>;
+    constructor(data: SelectData<Meta>);
+    as(alias: string): SubQuery<Input>;
+    from(target: HasTarget): Select<Input, Meta>;
+    leftJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
+    rightJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
+    innerJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
+    fullJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
+    where(where: HasSql<boolean>): Select<Input, Meta>;
+    groupBy(...exprs: Array<HasSql>): Select<Input, Meta>;
+    having(having: HasSql<boolean>): Select<Input, Meta>;
+    orderBy(...exprs: Array<HasSql>): Select<Input, Meta>;
+    limit(limit: UserInput<number>): Select<Input, Meta>;
+    offset(offset: UserInput<number>): Select<Input, Meta>;
+    union(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    unionAll(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    intersect(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    intersectAll(this: SelectBase<Input, IsPostgres | IsMysql>, right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    except(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    exceptAll(right: SelectBase<Input, IsPostgres | IsMysql>): Union<Input, Meta>;
+    get [internalSelection](): import("../Selection.ts").Selection;
+    get [internalQuery](): import("../Sql.ts").Sql<unknown>;
+}
+export type SubQuery<Input> = Input & HasTarget;
+export interface SelectBase<Input, Meta extends QueryMeta = QueryMeta> extends Query<SelectionRow<Input>, Meta>, HasSelection {
+    where(where: HasSql<boolean>): Select<Input, Meta>;
+    groupBy(...exprs: Array<HasSql>): Select<Input, Meta>;
+    having(having: HasSql<boolean>): Select<Input, Meta>;
+    orderBy(...exprs: Array<HasSql>): Select<Input, Meta>;
+    limit(limit: UserInput<number>): Select<Input, Meta>;
+    offset(offset: UserInput<number>): Select<Input, Meta>;
+    union(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    unionAll(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    intersect(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    intersectAll(this: SelectBase<Input, IsPostgres | IsMysql>, right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    except(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    exceptAll(right: SelectBase<Input, IsPostgres | IsMysql>): Union<Input, Meta>;
+    as(name: string): SubQuery<Input>;
+}
+export interface WithoutSelection<Meta extends QueryMeta> {
+    from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): AllFrom<TableFields<Definition>, Meta, Record<Name, TableFields<Definition>>>;
+    from<Input>(from: SubQuery<Input>): SelectionFrom<Input, Meta>;
+}
+export interface WithSelection<Input, Meta extends QueryMeta> {
+    from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): SelectionFrom<Input, Meta>;
+    from(from: SubQuery<unknown>): SelectionFrom<Input, Meta>;
+}
+export interface AllFrom<Input, Meta extends QueryMeta, Tables = Input> extends SelectBase<Input, Meta> {
+    leftJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<Tables & MakeNullable<Record<Name, TableFields<Definition>>>>, Meta>;
+    rightJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & Record<Name, TableFields<Definition>>>, Meta>;
+    innerJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<Tables & Record<Name, TableFields<Definition>>>, Meta>;
+    fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & MakeNullable<Record<Name, TableFields<Definition>>>>, Meta>;
+}
+type MarkFieldsAsNullable<Input, TableName extends string> = Expand<{
+    [K in keyof Input]: Input[K] extends Field<infer T, TableName> ? HasSql<T | null> : Input[K] extends Table<infer Definition, TableName> ? TableFields<Definition> & IsNullable : Input[K] extends Record<string, Field<unknown, TableName> | HasSql<unknown>> ? Input[K] & IsNullable : Input[K] extends SelectionRecord ? MarkFieldsAsNullable<Input[K], TableName> : Input[K];
+}>;
+export interface SelectionFrom<Input, Meta extends QueryMeta> extends SelectBase<Input, Meta> {
+    leftJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
+    rightJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    innerJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+}
+export {};