inferred-types 0.15.0 → 0.18.0

package/dist/types/utility/keys.d.ts

@@ -1,5 +0,0 @@
-import { Keys, Length } from "../types/index";
-/**
- * Provides the _keys_ of an object with the `keyof T` made explicit.
- */
-export declare function keys<T extends {}, W extends readonly string[]>(obj: T, ...without: W): Length<W> extends 0 ? (keyof T)[] : Exclude<keyof T, Keys<W, undefined>>[];

package/dist/types/utility/literals/ExplicitFunction.d.ts

@@ -1,6 +0,0 @@
-export declare type ExplicitFunction<P extends any[], R extends any> = (...args: P) => R;
-/**
- * Takes a given function and converts it to an explicit representation
- * where the generics represent the _parameter_ and _return_ typings.
- */
-export declare function ExplicitFunction<T extends (...args: any[]) => any>(fn: T): ExplicitFunction<Parameters<T>, ReturnType<T>>;

package/dist/types/utility/literals/arrayToObject.d.ts

@@ -1,41 +0,0 @@
-import { Narrowable } from "../../types/Narrowable";
-/**
- * **UniqueDictionary**
- *
- * A dictionary converted by `arrayToObject()` which expects each key `S` to have a only a
- * single/unique value.
- */
-export declare type UniqueDictionary<S extends PropertyKey, N extends Narrowable, T extends Record<keyof T, N> & Record<S, any>> = {
-    [V in T as V[S]]: V;
-};
-/**
- * **GeneralDictionary**
- *
- * A dictionary converted by `arrayToObject()` which expects each key `S` to have an
- * array of values.
- */
-export declare type GeneralDictionary<S extends PropertyKey, N extends Narrowable, T extends Record<keyof T, N> & Record<S, any>> = {
-    [V in T as V[S]]: V[];
-};
-export declare type ArrayConverter<S extends PropertyKey, U extends boolean> = 
-/**
- * An `ArrayConverter` is the partial application of the `arrayToObject()`
- * utility. At this point, the configuration is setup already and all that's
- * left is to pass in an array of objects.
- */
-<N extends Narrowable, T extends Record<keyof T, N> & Record<S, any>>(arr: readonly T[]) => true extends U ? UniqueDictionary<S, N, T> : GeneralDictionary<S, N, T>;
-/**
- * Converts an array of objects into a dictionary by picking a property name contained
- * by all objects and using that as the key to the dictionary.
- *
- * ```ts
- * const arr = [
- *   { kind: "color", favorite: "blue", likes: 100 },
- *   { kind: "song", favorite: "some song", likes: 25 }
- * ];
- * const dict = arrayToObject("kind")(arr);
- * ```
- *
- * This will produce a dictionary with keys of `color` and `song`.
- */
-export declare function arrayToObject<S extends PropertyKey, U extends boolean>(prop: S, unique?: U): ArrayConverter<S, true extends U ? true : false>;

package/dist/types/utility/literals/defineType.d.ts

@@ -1,8 +0,0 @@
-import { ExpandRecursively, Narrowable } from "../../types/index";
-/**
- * Build a _type_ from two run-time dictionaries.
- *
- * 1. The _first_ -- which is optional -- is interpreted as a _literal_ type definition
- * 2. The _second_ dictionary is interpreted as a "wide" definition of prop types
- */
-export declare function defineType<N extends Narrowable, TLiteral extends Record<string, N>>(literal?: TLiteral): <TWide extends object>(wide?: TWide) => ExpandRecursively<TWide & TLiteral>;

package/dist/types/utility/literals/identity.d.ts

@@ -1,6 +0,0 @@
-import { Narrowable } from "../../types/Narrowable";
-/**
- * An identity function for any type, with the goal of preserving literal type information
- * whereever possible.
- */
-export declare const identity: <N extends Narrowable, T extends string | number | boolean | symbol | Record<any, N> | null | undefined>(v: T) => T;

package/dist/types/utility/literals/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./ExplicitFunction";
-export * from "./arrayToObject";
-export * from "./defineType";
-export * from "./identity";
-export * from "./literal";

package/dist/types/utility/literals/literal.d.ts

@@ -1,41 +0,0 @@
-import { Narrowable } from "../../types/index";
-/**
- * Takes an object as input --which has an `id` property and returns it as the same
- * run-time content but with the _type_ of the `id` property being forced to a literal type
- */
-export declare function idLiteral<T extends {
-    id: I;
-}, I extends PropertyKey>(o: T): T & {
-    id: T["id"];
-};
-/**
- * Takes an object as input --which has an `name` property and returns it as the same
- * run-time content but with the _type_ of the `name` property being forced to a literal type
- */
-export declare function nameLiteral<T extends {
-    name: I;
-}, I extends PropertyKey>(o: T): T & {
-    name: T["name"];
-};
-/**
- * Takes an object as input --which has an `kind` property and returns it as the same
- * run-time content but with the _type_ of the `kind` property being forced to a literal type
- */
-export declare function kindLiteral<T extends {
-    kind: I;
-}, I extends PropertyKey>(o: T): T & {
-    kind: T["kind"];
-};
-export declare function idTypeGuard<T extends {
-    id: I;
-}, I extends PropertyKey>(_o: T): _o is T & {
-    id: I;
-};
-/**
- * Takes an object as input and infers the narrow literal types of the property
- * values on the object.
- *
- * > Note: this addresses this [a known TS gap](https://github.com/microsoft/TypeScript/issues/30680).
- * > Hopefully at some point this will be addressed in the language.
- */
-export declare function literal<N extends Narrowable, T extends Record<keyof T, N>>(obj: T): T;

package/dist/types/utility/map-reduce/filter.d.ts

@@ -1,26 +0,0 @@
-export declare type Filter<A> = {
-    kind: "Equals";
-    field: keyof A;
-    val: A[keyof A];
-} | {
-    kind: "Greater";
-    field: keyof A;
-    val: A[keyof A];
-} | {
-    kind: "Less";
-    field: keyof A;
-    val: A[keyof A];
-} | {
-    kind: "And";
-    a: Filter<A>;
-    b: Filter<A>;
-} | {
-    kind: "Or";
-    a: Filter<A>;
-    b: Filter<A>;
-};
-export declare const equals: <A, K extends keyof A>(field: K, val: A[K]) => Filter<A>;
-export declare const greater: <A, K extends keyof A>(field: K, val: A[K]) => Filter<A>;
-export declare const less: <A, K extends keyof A>(field: K, val: A[K]) => Filter<A>;
-export declare const and: <A>(a: Filter<A>, b: Filter<A>) => Filter<A>;
-export declare const or: <A>(a: Filter<A>, b: Filter<A>) => Filter<A>;

package/dist/types/utility/map-reduce/index.d.ts

@@ -1 +0,0 @@
-export * from "./filter";

package/dist/types/utility/modelling/IoModel.d.ts

@@ -1,26 +0,0 @@
-import * as t from "io-ts";
-import type { PascalCase } from "../../types/index";
-/**
- * Defines an `io-ts` based **model**.
- *
- * - `<T>` represents type of the model
- * - `<S>` is the model's literal type
- *
- * Note: unlink the default `io-ts` model/codec, the
- * `name` variable is an explicit type alias and not a string
- * type. This helps to preserve it's type inference even though
- * the model itself does have a runtime definition of it's type.
- */
-export declare type IoModel<M, N extends string> = Omit<t.Type<M>, "name"> & {
-    name: N;
-};
-/**
- * **Model**
- *
- * A function which returns a `io-ts` based model/codec but with a _literal_ name
- * property, and a `kind` which uniquely distinguishes itself as a "model".
- *
- * **Note:** the name of a model is expected to be in _PascalCase_ and will be converted
- * to it if not passed in correctly.
- */
-export declare function IoModel<RP extends t.Props, OP extends t.Props | {}, N extends string>(name: N, req: RP, optional?: OP): IoModel<{ [K in keyof RP]: t.TypeOf<RP[K]>; } & { [K_1 in keyof OP]?: t.TypeOf<OP[K_1]> | undefined; }, PascalCase<N>>;

package/dist/types/utility/modelling/Model.d.ts

@@ -1,22 +0,0 @@
-export declare function Model<N extends string, _R extends {} = {}, _O extends {} = {}>(name: N): {
-    required<P extends string>(_prop: P): {
-        required<P_1 extends string>(_prop: P_1): any;
-        optional<P_2 extends string>(_prop: P_2): any;
-        done(): {
-            __model__: N;
-            __kind__: "model";
-        };
-    };
-    optional<P_3 extends string>(_prop: P_3): {
-        required<P_1 extends string>(_prop: P_1): any;
-        optional<P_2 extends string>(_prop: P_2): any;
-        done(): {
-            __model__: N;
-            __kind__: "model";
-        };
-    };
-    done(): {
-        __model__: N;
-        __kind__: "model";
-    };
-};

package/dist/types/utility/modelling/index.d.ts

@@ -1 +0,0 @@
-export * from "./Model";

package/dist/types/utility/ruleset.d.ts

@@ -1,18 +0,0 @@
-import type { Narrowable } from "../types/index";
-/**
- * **ruleSet**
- *
- * Defines a ruleset composed of _dynamic_ and _static_ boolean operators.
- *
- * - the first function call defines _dynamic_ props (_optional_)
- * - the second function call defines static values
- *
- * ```ts
- * const rs = ruleSet(
- *    r => r.state()( { maybe: r => r.extends({ foo: 1 }) })
- * )(
- *    { color: true, age: false }
- * );
- * ```
- */
-export declare function ruleSet<N extends Narrowable, TState extends Record<keyof TState, N>>(defn?: TState): TState | undefined;

package/dist/types/utility/runtime/condition.d.ts

@@ -1,3 +0,0 @@
-import { Narrowable } from "../../types/index";
-export declare type Condition<TInput extends Narrowable, TResult extends boolean> = (input: TInput) => TResult;
-export declare const condition: <TInput extends Narrowable, C extends Condition<Narrowable, boolean>>(c: C, input: TInput) => boolean;

package/dist/types/utility/runtime/conditions/index.d.ts

@@ -1,12 +0,0 @@
-export * from "./isArray";
-export * from "./isBoolean";
-export * from "./isFalse";
-export * from "./isFunction";
-export * from "./isLiteral";
-export * from "./isNull";
-export * from "./isNumber";
-export * from "./isObject";
-export * from "./isString";
-export * from "./isSymbol";
-export * from "./isTrue";
-export * from "./isUndefined";

package/dist/types/utility/runtime/conditions/isArray.d.ts

@@ -1,2 +0,0 @@
-export declare type IsArray<T> = T extends any[] ? true : false;
-export declare function isArray<T>(i: T): IsArray<T>;

package/dist/types/utility/runtime/conditions/isBoolean.d.ts

@@ -1,5 +0,0 @@
-export declare type IsBoolean<T> = T extends boolean ? true : false;
-/**
- * Runtime and type checks whether a variable is a boolean value.
- */
-export declare function isBoolean<T extends any>(i: T): IsBoolean<T>;

package/dist/types/utility/runtime/conditions/isFalse.d.ts

@@ -1,4 +0,0 @@
-import { Narrowable } from "../../../types/index";
-import { IsBoolean } from "../../index";
-export declare type IsFalse<T extends Narrowable> = IsBoolean<T> extends true ? T extends false ? true : true extends T ? false : unknown : false;
-export declare function isFalse<T>(i: T): IsFalse<T>;

package/dist/types/utility/runtime/conditions/isFunction.d.ts

@@ -1,15 +0,0 @@
-import { FunctionType } from "../../../types/index";
-export declare type IsFunction<T> = T extends FunctionType ? true : false;
-/**
- * Checks whether a passed in value is a function and ensures run-time and types
- * are consistent.
- * ```ts
- * // true
- * const yup = isFunction(() => "hello world");
- * ```
- *
- * Note: the runtime `typeof [variable]` will correctly say "function" when a function is
- * encounted but if that function also has object types defined then the type will be a big
- * and ugly union type. This function will give you a proper boolean value in both cases.
- */
-export declare function isFunction<T extends unknown>(input: T): IsFunction<T>;

package/dist/types/utility/runtime/conditions/isLiteral.d.ts

@@ -1,2 +0,0 @@
-export declare type IsLiteral<L extends string | number, T extends any> = T extends L ? true : false;
-export declare function isLiteral<L extends Readonly<string>>(...allowed: L[]): <T extends unknown>(i: T) => IsLiteral<L, T>;

package/dist/types/utility/runtime/conditions/isNull.d.ts

@@ -1 +0,0 @@
-export declare function isNull<T>(i: T): T extends null ? true : false;

package/dist/types/utility/runtime/conditions/isNumber.d.ts

@@ -1 +0,0 @@
-export declare function isNumber<T>(i: T): T extends number ? true : false;

package/dist/types/utility/runtime/conditions/isObject.d.ts

@@ -1,10 +0,0 @@
-import { FunctionType, Mutable, Narrowable, Not } from "../../../types/index";
-export declare type IsObject<T> = Mutable<T> extends Record<string, any> ? T extends FunctionType ? false : Mutable<T> extends any[] ? false : true : false;
-export declare type ObjectType = Not<Record<string, Narrowable>, FunctionType>;
-/**
- * Detects whether the passed in `v` is of type "object" where an object
- * is defined to be a string keyed dictionary style object. This means that
- * arrays are excluded, as well as functions which also have properties hanging
- * off of them.
- */
-export declare function isObject<T extends unknown>(i: T): IsObject<T>;

package/dist/types/utility/runtime/conditions/isString.d.ts

@@ -1,2 +0,0 @@
-export declare type IsString<T> = T extends string ? true : false;
-export declare function isString<T>(i: T): IsString<T>;

package/dist/types/utility/runtime/conditions/isSymbol.d.ts

@@ -1 +0,0 @@
-export declare function isSymbol<T>(i: T): T extends symbol ? true : false;

package/dist/types/utility/runtime/conditions/isTrue.d.ts

@@ -1,20 +0,0 @@
-import { Narrowable } from "../../../types/index";
-import type { IsBoolean } from "./isBoolean";
-/**
- * Type utility which returns `true` or `false` based on
- * whether the type holds the narrow "true" type.
- * ```ts
- * // true
- * type T = IsTrue<true>;
- * // unknown
- * type U = IsTrue<boolean>;
- * // false
- * type F = IsTrue<false>;
- * type F2 = IsTrue<"false">;
- * ```
- */
-export declare type IsTrue<T> = IsBoolean<T> extends true ? T extends true ? true : T extends false ? false : unknown : false;
-/**
- * Run-time and type checking of whether a variable is `true`.
- */
-export declare function isTrue<T extends Narrowable>(i: T): IsTrue<T>;

package/dist/types/utility/runtime/conditions/isUndefined.d.ts

@@ -1 +0,0 @@
-export declare function isUndefined<T>(i: T): undefined extends T ? true : false;

package/dist/types/utility/runtime/ifTypeOf.d.ts

@@ -1,23 +0,0 @@
-import { Narrowable } from "../../types/Narrowable";
-/**
- * A conditional clause used in the application of the `ifTypeOf` utility
- */
-export declare type ExtendsClause<N extends Narrowable, TValue extends Record<keyof TValue, N> | number | string | boolean | symbol> = <TBase extends any>(base: TBase) => TValue extends TBase ? true : false;
-/**
- * A conditional clause used in the application of the `ifTypeOf` utility
- */
-export declare type ExtendsNarrowlyClause<N extends Narrowable, TValue extends Record<keyof TValue, N> | number | string | boolean | symbol> = <NB extends Narrowable, TBase extends Record<keyof TBase, NB> | number | string | boolean | symbol>(base: TBase) => TValue extends TBase ? true : false;
-/**
- * **TypeCondition**
- *
- * A partially applied type from the `ifTypeOf` utility where the base type has been
- * defined and we now need to express the type which is intended to extend it.
- *
- * - `extends` - compares with _wide_ types
- * - `narrowlyExtends` - compares with _narrow_ / _literal_ types
- */
-export declare type TypeCondition<N extends Narrowable, TValue extends Record<keyof TValue, N> | number | string | boolean | symbol> = {
-    extends: ExtendsClause<N, TValue>;
-    narrowlyExtends: ExtendsNarrowlyClause<N, TValue>;
-};
-export declare const ifTypeOf: <N extends Narrowable, TValue extends string | number | boolean | symbol | Record<keyof TValue, N>>(val: TValue) => TypeCondition<N, TValue>;

package/dist/types/utility/runtime/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./condition";
-export * from "./ifTypeOf";
-export * from "./type";
-export * from "./withValue";
-export * from "./conditions/index";

package/dist/types/utility/runtime/type.d.ts

@@ -1,27 +0,0 @@
-import { Narrowable, TypeGuard } from "../../types/index";
-import { isString, isBoolean, isNumber, isFunction, isSymbol, isNull, isTrue, isFalse, isUndefined, isObject, isArray } from "./conditions/index";
-export declare type Type<T extends any, V extends Function> = {
-    name: string;
-    type: T;
-    typeGuard: TypeGuard<T>;
-    is: V;
-};
-export declare const typeApi: () => {
-    readonly string: Type<string, typeof isString>;
-    readonly boolean: Type<boolean, typeof isBoolean>;
-    readonly number: Type<number, typeof isNumber>;
-    readonly function: Type<Function | (Function & {
-        [key: string]: any;
-    }), typeof isFunction>;
-    readonly null: Type<null, typeof isNull>;
-    readonly symbol: Type<symbol, typeof isSymbol>;
-    readonly undefined: Type<undefined, typeof isUndefined>;
-    readonly true: Type<true, typeof isTrue>;
-    readonly false: Type<false, typeof isFalse>;
-    readonly object: Type<Record<string, Narrowable>, typeof isObject>;
-    readonly array: Type<any[], typeof isArray>;
-};
-export declare type TypeApi = ReturnType<typeof typeApi>;
-export declare function isType<T extends any, V extends Function>(t: unknown): t is Type<T, V>;
-export declare type TypeDefinition<T extends any, V extends Function> = (defn: TypeApi) => Type<T, V>;
-export declare function type<T extends any, V extends Function>(fn: TypeDefinition<T, V>): Type<T, V>;

package/dist/types/utility/runtime/withValue.d.ts

@@ -1,19 +0,0 @@
-import { ExpandRecursively, Narrowable } from "../../types/index";
-import { TypeDefinition } from "./index";
-/**
- * **withValue**
- *
- * Reduces a dictionary object -- in both _type_ and _run-time_ structure -- to only those
- * key/value pairs which have a specified value. For instance:
- *
- * ```ts
- * const obj = { foo: 1, bar: 2, message: "hi there" };
- * // { message: "hi there" }
- * const onlyStrings = withValue(t => t.string)(obj);
- * // { foo: 1 }
- * const justOne = withValue(t => t.literal(1))(obj);
- * ```
- *
- * Note: _often useful to provide run-time type profiles with the_ `inferredType` _utility_
- */
-export declare function withValue<T extends any, V extends Function>(td: TypeDefinition<T, V>): <N extends Narrowable, R extends Record<string, N>>(obj: R) => ExpandRecursively<Pick<R, import("../../types/index").KeysWithValue<T, R>>>;

package/dist/types/utility/state/Configurator.d.ts

@@ -1,36 +0,0 @@
-import { ExpandRecursively } from "../../types/index";
-export interface IConfigurator<C = {}> {
-    set<V, K extends string, KV = {
-        [U in K]: V;
-    }>(key: K, value: V): asserts this is IConfigurator<ExpandRecursively<C & KV>>;
-    remove<K extends string & keyof C>(key: K): asserts this is IConfigurator<ExpandRecursively<Omit<C, K>>>;
-    done(): C;
-}
-/**
- * **Configurator**
- *
- * This function provides a configurator which uses TypeScript assertions
- * to narrow the scope of variables. Using type assertions though means we
- * can't also return values and therefore a _fluent_ API style is not possible.
- *
- * Note: this approach does require, that you explicitly use the `IConfigurator`
- * interface exported by this library. Without it you'd getting annoying TS errors
- * on every call to `set()` but adding it is simple enough:
- *
- * ```ts
- * import { Configurator, IConfigurator } from "inferred-types";
- * const config: IConfigurator = Configurator();
- * ```
- *
- * If you want to specify some guideline params which you expect to be set, you
- * can add them like so:
- *
- * ```ts
- * export type IExpected = { foo: number, bar: string };
- * const config: IConfigurator<IExpected> = Configurator<IExpected>();
- * ```
- *
- * This configuration will ensure that `foo` and `bar` will be seen as optional
- * parameters. If you set them they will stop being optional.
- */
-export declare function Configurator(): IConfigurator<{}>;

package/dist/types/utility/state/FluentConfigurator.d.ts

@@ -1,27 +0,0 @@
-import type { ExpandRecursively } from "../../types/index";
-export interface IFluentConfigurator<C> {
-    /**
-     * **set**
-     *
-     * Sets a new key/value pair to the configurator.
-     *
-     * @param key the key to put this new configuration item
-     * @param value the value of the configuration item
-     */
-    set<V, K extends string, KV = {
-        [U in K]: V;
-    }>(key: K, value: V): IFluentConfigurator<C & KV>;
-    done(): ExpandRecursively<C>;
-}
-/**
- * This function will return a basic _configurator_ API surface which allows
- * you to add name/value pairs to a growing dictionary of strongly typed data.
- *
- * When configuration is complete, you call the `done()` endpoint and the typed
- * configuration will be returned with the API removed.
- *
- * > **Note:** the approach taken here requires that you configure using a **fluent style**
- * exclusively. If you don't the non-fluent properties set will not show up
- * in the typing or the run-time object.
- */
-export declare function FluentConfigurator<I>(initial?: I): IFluentConfigurator<{}>;

package/dist/types/utility/state/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./Configurator";
-export * from "./FluentConfigurator";
-export * from "./KeyStorage";

package/src/types/alphabetic/Intrinsic.ts

@@ -1,6 +0,0 @@
-/* eslint @typescript-eslint/no-unused-vars: "off" */
-
-export type Capitalize<T> = intrinsic;
-export type Uncapitalize<T> = intrinsic;
-export type Uppercase<T> = intrinsic;
-export type Lowercase<T> = intrinsic;

package/src/utility/modelling/IoModel.ts

@@ -1,38 +0,0 @@
-import * as t from "io-ts";
-import { pascalize } from "native-dash";
-import type { PascalCase } from "~/types";
-
-/**
- * Defines an `io-ts` based **model**.
- *
- * - `<T>` represents type of the model
- * - `<S>` is the model's literal type
- *
- * Note: unlink the default `io-ts` model/codec, the
- * `name` variable is an explicit type alias and not a string
- * type. This helps to preserve it's type inference even though
- * the model itself does have a runtime definition of it's type.
- */
-export type IoModel<M, N extends string> = Omit<t.Type<M>, "name"> & { name: N };
-
-/**
- * **Model**
- *
- * A function which returns a `io-ts` based model/codec but with a _literal_ name
- * property, and a `kind` which uniquely distinguishes itself as a "model".
- *
- * **Note:** the name of a model is expected to be in _PascalCase_ and will be converted
- * to it if not passed in correctly.
- */
-export function IoModel<RP extends t.Props, OP extends t.Props | {}, N extends string>(
-  name: N,
-  req: RP,
-  optional: OP = {} as OP
-) {
-  const model = t.intersection([t.type(req), t.partial(optional)], name);
-  type T = t.TypeOf<typeof model>;
-  return {
-    ...(model as t.Type<T>),
-    name: pascalize(name),
-  } as IoModel<T, PascalCase<N>>;
-}

package/tests/FluentApi-spec.ts

@@ -1,90 +0,0 @@
-import type { Expect, Equal, ExpectExtends, ExpectFalse } from "@type-challenges/utils";
-import { FluentApi, Keys } from "~/types";
-
-const escape = {
-  hi: () => "hello",
-};
-const fluent = {
-  foo: () => ({ ...fluent, ...escape }),
-  bar: () => ({ ...fluent, ...escape }),
-};
-const fluentSolo = {
-  foo: () => fluentSolo,
-  bar: () => fluentSolo,
-};
-
-describe("FluentApi type", () => {
-  it("Fluent API without escape API can be used as FluentAPI", () => {
-    const api: FluentApi<typeof fluentSolo> = fluentSolo;
-    type Api = typeof api;
-
-    type cases = [
-      // Api extends the type FluentApi
-      Expect<ExpectExtends<FluentApi<any, any, any>, Api>>,
-      // the fluent API keys are found on API
-      Expect<ExpectExtends<Keys<Api>, "foo" | "bar">>,
-      // the fluent API returns itself
-      Expect<Equal<Api, ReturnType<Api["bar"]>>>,
-      Expect<Equal<Api, ReturnType<Api["foo"]>>>
-    ];
-    const cases: cases = [true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("Simple fluent API and escape API are combined", () => {
-    const api: FluentApi<typeof fluent, typeof escape> = { ...fluent, ...escape };
-    type Api = typeof api;
-
-    type cases = [
-      // Api extends the type FluentApi
-      Expect<ExpectExtends<FluentApi<any, any, any>, Api>>,
-      // the fluent and escape api keys are found on API
-      Expect<ExpectExtends<Keys<Api>, "foo" | "bar" | "hi">>,
-      // the fluent API returns itself
-      Expect<Equal<Api, ReturnType<Api["bar"]>>>,
-      Expect<Equal<Api, ReturnType<Api["foo"]>>>,
-      // whereas the escape API just returns a string
-      Expect<Equal<string, ReturnType<Api["hi"]>>>
-    ];
-    const cases: cases = [true, true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("Exclusion masks certain API endpoints", () => {
-    const api1: FluentApi<typeof fluent, typeof escape, "hi"> = { ...fluent, ...escape };
-    type Api1 = typeof api1;
-    const api2: FluentApi<typeof fluent, typeof escape, "foo" | "bar"> = { ...fluent, ...escape };
-    type Api2 = typeof api2;
-
-    type cases = [
-      // excluding "hi" hides the escape api but leaves fluent API untouched
-      Expect<ExpectExtends<"foo" | "bar", Keys<Api1>>>,
-      ExpectFalse<ExpectExtends<"hi", Keys<Api1>>>,
-      // similarly hiding "foo" and "bar" leaves the escape API untouched
-      Expect<ExpectExtends<"hi", Keys<Api2>>>,
-      ExpectFalse<ExpectExtends<"foo" | "bar", Keys<Api2>>>
-    ];
-
-    const cases: cases = [true, false, true, false];
-    expect(cases).toBe(cases);
-  });
-
-  it("applying different FluentApi exclusions to the same runtime API modifies the API appropriately", () => {
-    const api1: FluentApi<typeof fluent, typeof escape, "hi"> = { ...fluent, ...escape };
-    type Api1 = typeof api1;
-    const api2: FluentApi<typeof fluent, typeof escape, "foo" | "bar"> = api1 as any;
-    type Api2 = typeof api2;
-
-    type cases = [
-      // excluding "hi" hides the escape api but leaves fluent API untouched
-      Expect<ExpectExtends<"foo" | "bar", Keys<Api1>>>,
-      ExpectFalse<ExpectExtends<"hi", Keys<Api1>>>,
-      // similarly hiding "foo" and "bar" leaves the escape API untouched
-      Expect<ExpectExtends<"hi", Keys<Api2>>>,
-      ExpectFalse<ExpectExtends<"foo" | "bar", Keys<Api2>>>
-    ];
-
-    const cases: cases = [true, false, true, false];
-    expect(cases).toBe(cases);
-  });
-});