/**
 * Casts a type (unless it's already narrower)
 * @example
 * // returns 'hey'
 * Cast<'hey', string>
 * @example
 * // returns string
 * Cast<unknown, string>
 */
export declare type Cast<TType, TBroadType> = TType extends TBroadType ? TType : TBroadType;
/**
 * Gets a subtype of a collection type (object, array, tuple)
 * @example
 * Get<{name: string, pronoums: ['they','them']}, 'pronoums'> //['they','them']
 *
 * You can also get within a nested collection by passing a tuple
 * @example
 * Get<{user: { name: string, pronoums: ['they','them']}}, ['user', 'pronoums', 0]> //'they'
 */
export declare type Get<TCollection, TKeys, TFallback = undefined> = TKeys extends any[] ? TKeys extends [] ? TCollection extends undefined ? TFallback : TCollection : TKeys extends [infer K1, ...infer Kr] ? K1 extends keyof TCollection ? Get<TCollection[K1], Kr, TFallback> extends infer X ? Cast<X, any> : never : TFallback : never : Get<TCollection, [TKeys], TFallback>;
export declare type AreEqual<A, B> = (<T>() => T extends B ? 1 : 0) extends <T>() => T extends A ? 1 : 0 ? true : false;
export declare type DoesExtend<A, B> = A extends B ? true : false;
export declare type IsPlainObject<TType> = Bool.And<DoesExtend<TType, A.Object>, Bool.Not<DoesExtend<TType, A.Function>>>;
export declare namespace A {
    /**
     * Aliases for common generic types
     */
    type Function = (...args: any[]) => any;
    type Tuple<T = any> = T[] | [T];
    type TupleOrUnit<T> = T | Tuple<T>;
    type Object = object;
    type String = string;
    type Number = number;
    type Universal = string | number | boolean | undefined | null | bigint | object | ((...a: any[]) => any);
}
export declare namespace Obj {
    /**
     * Object Type utilities
     */
    type Assert<TType> = Cast<TType, A.Object>;
    type DeepReadonly<TObj> = {
        readonly [TKey in keyof TObj]: TObj[TKey] extends any ? TObj[TKey] extends A.Function ? TObj[TKey] : TObj[TKey] extends A.Object ? DeepReadonly<TObj[TKey]> : TObj[TKey] : never;
    };
    type KeyWithValue<TObj, TValueType> = {
        [Key in keyof TObj]: TObj[Key] extends TValueType ? Key : never;
    }[keyof TObj];
    type Mergify<TObj> = {
        [Key in keyof TObj]: TObj[Key];
    } & unknown;
    type Update<A, B> = Mergify<{
        [K in Union.Exclude<keyof A, keyof B>]: A[K];
    } & {
        [K in keyof B]: B[K];
    }>;
}
export declare namespace List {
    /**
     * Array and Tuple Type utilities
     */
    type Assert<TType> = Cast<TType, A.Tuple>;
    type Concat<A, B> = [...List.Assert<A>, ...List.Assert<B>];
    type Pushed<TTuple, TType> = [...List.Assert<TTuple>, TType];
    type Popped<TTuple> = TTuple extends [] ? [] : TTuple extends [...infer Popped, any] ? Popped : never;
    type Pop<TTuple> = TTuple extends [] ? undefined : TTuple extends [...List.Popped<TTuple>, infer X] ? X : never;
    type Shifted<TTuple> = TTuple extends [] ? [] : TTuple extends [any, ...infer Shifted] ? Shifted : never;
    type Unshift<A, X> = [X, ...List.Assert<A>];
    type Shift<TTuple> = TTuple extends [] ? undefined : TTuple extends [infer X, ...infer _] ? X : never;
    type ConcatAll<TTuples> = TTuples extends [] ? [] : TTuples extends [infer A] ? A : TTuples extends [infer A, infer B, ...infer X] ? ConcatAll<[List.Concat<A, B>, ...X]> : never;
    type Join<TTuple, TDelimeter> = TTuple extends [] ? "" : TTuple extends [infer H, ...infer T] ? T extends [] ? H : `${String.Assert<H>}${String.Assert<TDelimeter>}${Join<T, TDelimeter>}` : string;
    type Includes<TTuple, TValue> = TTuple extends [] ? false : TValue extends Get<TTuple, number> ? true : false;
    type Filter<TTuple, TValue = Filter.Out> = TTuple extends [] ? [] : TTuple extends [infer H, ...infer T] ? H extends TValue ? Filter<T, TValue> : [H, ...Filter<T, TValue>] : never;
    namespace Filter {
        const Out: unique symbol;
        export type Out = typeof Out;
        export {};
    }
}
export declare namespace Union {
    /**
     * Union type utilities
     */
    type IsUnit<T> = [Union.Popped<T>] extends [never] ? true : false;
    type Popped<TUnion> = Union.Exclude<TUnion, Union.Pop<TUnion>>;
    type Exclude<TUnion, TValue> = TUnion extends TValue ? never : TUnion;
    type Extract<TUnion, TValue> = TUnion extends TValue ? TUnion : never;
    type Pop<TUnion> = ToIntersection<TUnion extends unknown ? (x: TUnion) => void : never> extends (x: infer P) => void ? P : never;
    type ToIntersection<TUnion> = (TUnion extends unknown ? (k: TUnion) => void : never) extends (k: infer I) => void ? I : never;
    type ToTuple<TUnion> = [TUnion] extends [never] ? [] : [...Union.ToTuple<Union.Popped<TUnion>>, Union.Pop<TUnion>];
}
export declare namespace Bool {
    /**
     * Boolean Type utilities
     */
    type Not<B> = B extends true ? false : true;
    type And<A, B> = AreEqual<Union.ToIntersection<Get<[A, B], number>>, true>;
}
export declare namespace String {
    /**
     * String type utilities
     */
    type Assert<TType> = Cast<TType, A.String>;
    type IsLiteral<TType> = TType extends A.String ? (A.String extends TType ? false : true) : false;
    type DoesStartWith<TString, TValue> = TString extends TValue ? true : TString extends `${String.Assert<TValue>}${infer _}` ? true : false;
    type DoesContain<TString, TValue> = TString extends TValue ? true : TString extends `${infer _}${String.Assert<TValue>}${infer __}` ? true : false;
    type Split<TString, TDelimiter> = TString extends `${infer H}${String.Assert<TDelimiter>}${infer T}` ? [H, ...Split<T, TDelimiter>] : [TString];
    type Replace<TString, TWhat, TWith> = TString extends `${infer P}${String.Assert<TWhat>}${infer S}` ? `${P}${String.Assert<TWith>}${Replace<S, TWhat, TWith>}` : TString;
    type Shifted<TString> = TString extends `${infer _}${infer T}` ? T : "";
}
export declare namespace Num {
    type Assert<T> = Cast<T, A.Number>;
    type PositiveIntegers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
    type NegativeIntegers = [
        -1,
        -2,
        -3,
        -4,
        -5,
        -6,
        -7,
        -8,
        -9,
        -10,
        -11,
        -12,
        -13,
        -14,
        -15,
        -16,
        -17,
        -18,
        -19,
        -20
    ];
    type PositiveIntegersUnshifted = List.Unshift<PositiveIntegers, 0>;
    type PositiveIntegersUnshiftedTwice = List.Unshift<PositiveIntegersUnshifted, -1>;
    type NegativeIntegersUnshifted = List.Unshift<NegativeIntegers, 0>;
    type NegativeIntegersUnshiftedTwice = List.Unshift<NegativeIntegersUnshifted, 1>;
    type IsWhole<N> = Bool.Not<IsNegative<N>>;
    type IsNegative<N> = String.DoesStartWith<Num.ToString<N>, "-">;
    type Negate<N> = N extends 0 ? 0 : IsNegative<N> extends true ? Num.FromString<String.Shifted<Num.ToString<N>>> : Num.FromString<`-${Num.Assert<N>}`>;
    type ToString<X> = `${Num.Assert<X>}`;
    type FromString<S> = S extends "0" ? 0 : String.DoesStartWith<S, "-"> extends false ? {
        [I in keyof PositiveIntegersUnshifted]: I extends S ? PositiveIntegersUnshifted[I] : never;
    }[keyof PositiveIntegersUnshifted] : {
        [I in keyof NegativeIntegersUnshifted]: `-${Num.Assert<I>}` extends S ? NegativeIntegersUnshifted[I] : never;
    }[keyof NegativeIntegersUnshifted];
    type Increment<N> = IsNegative<N> extends false ? Get<PositiveIntegers, N> : Get<NegativeIntegersUnshiftedTwice, Num.Negate<N>>;
    type Decrement<N> = IsNegative<N> extends false ? Get<PositiveIntegersUnshiftedTwice, N> : Get<NegativeIntegers, Num.Negate<N>>;
}