diff --git a/package-lock.json b/package-lock.json
index 20fd581..de13dfc 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "string-literal-list",
-  "version": "1.22.0",
+  "version": "1.23.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "string-literal-list",
-      "version": "1.22.0",
+      "version": "1.23.0",
       "license": "MIT",
       "devDependencies": {
         "@types/node": "latest",
diff --git a/package.json b/package.json
index 1f2085b..f2ca681 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "string-literal-list",
-  "version": "1.22.0",
+  "version": "1.23.0",
   "description": "an array for string literal",
   "main": "stringList.cjs",
   "module": "stringList.js",
@@ -11,14 +11,14 @@
   "types": "stringList.d.ts",
   "exports": {
     ".": {
-      "types": "./stringList.js",
+      "types": "./stringList.d.ts",
       "require": "./stringList.cjs",
       "node": "./stringList.js",
       "import": "./stringList.min.js",
       "default": "./stringList.js"
     },
     "./strict.js": {
-      "types": "./strict.js",
+      "types": "./strict.d.ts",
       "require": "./strict.cjs",
       "node": "./strict.js",
       "import": "./strict.min.js",
@@ -28,7 +28,7 @@
       "default": "./types/index.js"
     },
     "./stringList.js": {
-      "types": "./stringList.js",
+      "types": "./stringList.d.ts",
       "require": "./stringList.cjs",
       "node": "./stringList.js",
       "import": "./stringList.min.js",
diff --git a/strict.d.ts b/strict.d.ts
index b433d61..2bf836b 100644
--- a/strict.d.ts
+++ b/strict.d.ts
@@ -1,9 +1,7 @@
-import { IStringList } from './types/list.js';
+export declare function stringList<
+  TT extends readonly string[] = readonly never[],
+>(...strings: TT): StringLiteralList.list.IStringList<TT, false, false>;
 
-export function stringList<TT extends readonly string[] = readonly never[]>(
+export declare function sl<TT extends readonly string[] = readonly never[]>(
   ...strings: TT
-): IStringList<TT, false, false>;
-
-export function sl<TT extends readonly string[] = readonly never[]>(
-  ...strings: TT
-): IStringList<TT, false, false>;
+): StringLiteralList.list.IStringList<TT, false, false>;
diff --git a/stringList.d.ts b/stringList.d.ts
index ba6b4f6..6b5b7e8 100644
--- a/stringList.d.ts
+++ b/stringList.d.ts
@@ -1,9 +1,7 @@
-import { IStringList } from './types/list.js';
+export declare function stringList<
+  TT extends readonly string[] = readonly never[],
+>(...strings: TT): StringLiteralList.list.IStringList<TT, true, false>;
 
-export function stringList<TT extends readonly string[] = readonly never[]>(
+export declare function sl<TT extends readonly string[] = readonly never[]>(
   ...strings: TT
-): IStringList<TT, true, false>;
-
-export function sl<TT extends readonly string[] = readonly never[]>(
-  ...strings: TT
-): IStringList<TT, true, false>;
+): StringLiteralList.list.IStringList<TT, true, false>;
diff --git a/stringListFunction.d.ts b/stringListFunction.d.ts
index bdc452b..7be53c7 100644
--- a/stringListFunction.d.ts
+++ b/stringListFunction.d.ts
@@ -1,12 +1,10 @@
 /// <reference path="./types/index.d.ts" />
 /// <reference path="./types/list.d.ts" />
 
-import { IStringList } from './types/list.js';
-
-export function stringListMutable<
+export declare function stringListMutable<
   TT extends readonly string[] = readonly never[],
->(...list: TT): IStringList<TT, true, false>;
+>(...list: TT): StringLiteralList.list.IStringList<TT, true, false>;
 
-export function stringListReadonly<
+export declare function stringListReadonly<
   TT extends readonly string[] = readonly never[],
->(...list: TT): IStringList<TT, false, false>;
+>(...list: TT): StringLiteralList.list.IStringList<TT, false, false>;
diff --git a/types/generic.d.ts b/types/generic.d.ts
index 48ff3c4..171761e 100644
--- a/types/generic.d.ts
+++ b/types/generic.d.ts
@@ -2,92 +2,91 @@
 import './index.js';
 
 declare global {
-  export namespace StringLiteralList {
-    export namespace generic {
-      /**
-       * Returns a tuple of the given length with the given type.
-       */
-      export type TupleOf<
-        L extends number,
-        T = unknown,
-        result extends any[] = [],
-      > = result['length'] extends L ? result : TupleOf<L, T, [...result, T]>;
+  export namespace StringLiteralList {}
+  export namespace StringLiteralList.generic {
+    /**
+     * Returns a tuple of the given length with the given type.
+     */
+    export type TupleOf<
+      L extends number,
+      T = unknown,
+      result extends any[] = [],
+    > = result['length'] extends L ? result : TupleOf<L, T, [...result, T]>;
 
-      export type Subtract<A extends number, B extends number> = number extends
-        | A
-        | B
-        ? number
-        : TupleOf<A> extends [...infer U, ...TupleOf<B>]
-          ? U['length']
-          : 0;
+    export type Subtract<A extends number, B extends number> = number extends
+      | A
+      | B
+      ? number
+      : TupleOf<A> extends [...infer U, ...TupleOf<B>]
+        ? U['length']
+        : 0;
 
-      export type IsNegative<T extends number> = number extends T
-        ? boolean
-        : `${T}` extends `-${number}`
-          ? true
-          : false;
+    export type IsNegative<T extends number> = number extends T
+      ? boolean
+      : `${T}` extends `-${number}`
+        ? true
+        : false;
 
-      export type Abs<T extends number> =
-        `${T}` extends `-${infer U extends number}` ? U : T;
+    export type Abs<T extends number> =
+      `${T}` extends `-${infer U extends number}` ? U : T;
 
-      /**
-       * Returns true if input number type is a literal
-       */
-      export type IsNumberLiteral<T extends number> = [T] extends [number]
-        ? [number] extends [T]
-          ? false
-          : true
-        : false;
+    /**
+     * Returns true if input number type is a literal
+     */
+    export type IsNumberLiteral<T extends number> = [T] extends [number]
+      ? [number] extends [T]
+        ? false
+        : true
+      : false;
 
-      export type IsBooleanLiteral<T extends boolean> = [T] extends [boolean]
-        ? [boolean] extends [T]
-          ? false
-          : true
-        : false;
+    export type IsBooleanLiteral<T extends boolean> = [T] extends [boolean]
+      ? [boolean] extends [T]
+        ? false
+        : true
+      : false;
 
-      /**
-       * Returns true if any elements in boolean array are the literal true (not false or boolean)
-       */
-      export type Any<Arr extends boolean[]> = Arr extends [
-        infer Head extends boolean,
-        ...infer Rest extends boolean[],
-      ]
-        ? IsBooleanLiteral<Head> extends true
-          ? Head extends true
-            ? true
-            : Any<Rest>
+    /**
+     * Returns true if any elements in boolean array are the literal true (not false or boolean)
+     */
+    export type Any<Arr extends boolean[]> = Arr extends [
+      infer Head extends boolean,
+      ...infer Rest extends boolean[],
+    ]
+      ? IsBooleanLiteral<Head> extends true
+        ? Head extends true
+          ? true
           : Any<Rest>
-        : false;
+        : Any<Rest>
+      : false;
 
-      export type Reject<
-        tuple,
-        cond,
-        output extends any[] = [],
-      > = tuple extends [infer first, ...infer rest]
-        ? Reject<rest, cond, first extends cond ? output : [...output, first]>
-        : output;
+    export type Reject<tuple, cond, output extends any[] = []> = tuple extends [
+      infer first,
+      ...infer rest,
+    ]
+      ? Reject<rest, cond, first extends cond ? output : [...output, first]>
+      : output;
 
-      /**
-       * Returns true if every element in boolean array is the literal true (not false or boolean)
-       */
-      export type All<Arr extends boolean[]> =
-        IsBooleanLiteral<Arr[number]> extends true
-          ? Arr extends [
-              infer Head extends boolean,
-              ...infer Rest extends boolean[],
-            ]
-            ? Head extends true
-              ? Any<Rest>
-              : false // Found `false` in array
-            : true // Empty array (or all elements have already passed test)
-          : false; // Array/Tuple contains `boolean` type
+    /**
+     * Returns true if every element in boolean array is the literal true (not false or boolean)
+     */
+    export type All<Arr extends boolean[]> =
+      IsBooleanLiteral<Arr[number]> extends true
+        ? Arr extends [
+            infer Head extends boolean,
+            ...infer Rest extends boolean[],
+          ]
+          ? Head extends true
+            ? Any<Rest>
+            : false // Found `false` in array
+          : true // Empty array (or all elements have already passed test)
+        : false; // Array/Tuple contains `boolean` type
 
-      export type UnionToIntersection<U> = (
-        U extends never ? never : (arg: U) => never
-      ) extends (arg: infer I) => void
-        ? I
-        : never;
-    }
+    export type UnionToIntersection<U> = (
+      U extends never ? never : (arg: U) => never
+    ) extends (arg: infer I) => void
+      ? I
+      : never;
   }
 }
+
 export {};
diff --git a/types/index.d.ts b/types/index.d.ts
index e6168a4..5a705f0 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -7,18 +7,7 @@
 import { ArrayInPlaceMutation } from '../StringLiteralList.js';
 
 declare global {
-  export namespace StringLiteralList {
-    // @ts-ignore
-    export * as tuple from './tuple.js';
-    // @ts-ignore
-    export * as list from './list.js';
-    // @ts-ignore
-    export * as record from './record.js';
-    // @ts-ignore
-    export * as string from './string.js';
-    // @ts-ignore
-    export * as generic from './generic.js';
-  }
+  export namespace StringLiteralList {}
 
   export namespace specs {
     /**
diff --git a/types/list.d.ts b/types/list.d.ts
index 1a2558c..95cd8ee 100644
--- a/types/list.d.ts
+++ b/types/list.d.ts
@@ -1,518 +1,574 @@
-import { sl } from './index.js';
-
-export interface ILiterals<Tuple extends readonly string[] = readonly never[]> {
-  /**
-   * Namespace to expose the type inference.
-   * The values are undefined and should not be used other than type inference.
-   */
-  infered: {
-    Tuple: Tuple;
-    TooLong: sl.string.Length<`${Tuple['length']}`> extends 5 | 6 | 7 | 8
-      ? true
-      : false;
-  };
-}
-
-export type MaybeReadonly<IsMutable extends boolean, A> = [IsMutable] extends [
-  true,
-]
-  ? A
-  : Readonly<A>;
-
-type RecordTypes = {
-  any: any;
-  string: string;
-  number: number;
-  boolean: boolean;
-  'string|number': string | number;
-  'number|boolean': number | boolean;
-  'any[]': any[];
-  'string[]': string[];
-  'number[]': number[];
-  'boolean[]': boolean[];
-  'Record<string, any>': Record<string, any>;
-  'Record<number, any>': Record<number, any>;
-  'Record<number, string>': Record<number, string>;
-  'Record<number, number>': Record<number, number>;
-  'Record<number, boolean>': Record<number, boolean>;
-  'Record<string, string>': Record<string, string>;
-  'Record<string, number>': Record<string, number>;
-  'Record<string, boolean>': Record<string, boolean>;
-  'Record<string, any[]>': Record<string, any[]>;
-  'Record<string, string[]>': Record<string, string[]>;
-  'Record<string, number[]>': Record<string, number[]>;
-  'Record<string, boolean[]>': Record<string, boolean[]>;
-};
-
-type RecordType = keyof RecordTypes;
-
-export interface IStringList<
-  Tuple extends readonly string[] = readonly never[],
-  Mut extends boolean = true,
-  Unsorted extends boolean = false,
-> extends Omit<Array<Tuple[number]>, specs.ImplementedMethod>,
-    ILiterals<Tuple> {
-  // Custom Methods
-  withPrefix<P extends string = ''>(
-    prefix: P,
-  ): sl.tuple.TuplePrefixed<
-    Tuple,
-    P extends string ? P : '',
-    []
-  > extends infer W extends readonly string[]
-    ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
-    : never;
-
-  withSuffix<P extends string>(
-    suffix: P,
-  ): P extends string
-    ? sl.tuple.TupleSuffixed<
+declare global {
+  namespace StringLiteralList {}
+  namespace StringLiteralList.list {
+    export interface ILiterals<
+      Tuple extends readonly string[] = readonly never[],
+    > {
+      /**
+       * Namespace to expose the type inference.
+       * The values are undefined and should not be used other than type inference.
+       */
+      infered: {
+        Tuple: Tuple;
+        TooLong: StringLiteralList.string.Length<`${Tuple['length']}`> extends
+          | 5
+          | 6
+          | 7
+          | 8
+          ? true
+          : false;
+      };
+    }
+
+    export type MaybeReadonly<IsMutable extends boolean, A> = [
+      IsMutable,
+    ] extends [true]
+      ? A
+      : Readonly<A>;
+
+    type RecordTypes = {
+      any: any;
+      string: string;
+      number: number;
+      boolean: boolean;
+      'string|number': string | number;
+      'number|boolean': number | boolean;
+      'any[]': any[];
+      'string[]': string[];
+      'number[]': number[];
+      'boolean[]': boolean[];
+      'Record<string, any>': Record<string, any>;
+      'Record<number, any>': Record<number, any>;
+      'Record<number, string>': Record<number, string>;
+      'Record<number, number>': Record<number, number>;
+      'Record<number, boolean>': Record<number, boolean>;
+      'Record<string, string>': Record<string, string>;
+      'Record<string, number>': Record<string, number>;
+      'Record<string, boolean>': Record<string, boolean>;
+      'Record<string, any[]>': Record<string, any[]>;
+      'Record<string, string[]>': Record<string, string[]>;
+      'Record<string, number[]>': Record<string, number[]>;
+      'Record<string, boolean[]>': Record<string, boolean[]>;
+    };
+
+    type RecordType = keyof RecordTypes;
+
+    export interface IStringList<
+      Tuple extends readonly string[] = readonly never[],
+      Mut extends boolean = true,
+      Unsorted extends boolean = false,
+    > extends Omit<Array<Tuple[number]>, specs.ImplementedMethod>,
+        ILiterals<Tuple> {
+      // Custom Methods
+      withPrefix<P extends string = ''>(
+        prefix: P,
+      ): StringLiteralList.tuple.TuplePrefixed<
         Tuple,
         P extends string ? P : '',
         []
       > extends infer W extends readonly string[]
-      ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
-      : never
-    : never;
-
-  // withDerivatedSuffix<S extends string>(
-  //   chars: S,
-  // ):
-  //   | T
-  //   | sl.string.DropSuffix<
-  //       sl.string.DropSuffix<`${T}${S}${S}`, S>,
-  //       `${S}${S}`
-  //     > extends infer W extends string
-  //   ? MaybeReadonly<Mut, IStringList<W, readonly W[], Mut, true>>
-  //   : never;
-
-  // withDerivatedPrefix<S extends string>(
-  //   chars: S,
-  // ):
-  //   | T
-  //   | sl.string.DropPrefix<
-  //       sl.string.DropPrefix<`${S}${S}${T}`, S>,
-  //       `${S}${S}`
-  //     > extends infer W extends string
-  //   ? MaybeReadonly<Mut, IStringList<W, readonly W[], Mut, true>>
-  //   : never;
-
-  withReplace<S extends string, D extends string>(
-    searchValue: S,
-    replaceValue: D,
-  ): sl.tuple.TupleWithReplace<Tuple, S, D, [], false> extends infer W extends
-    readonly string[]
-    ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
-    : never;
-
-  withReplaceAll<S extends string | RegExp, D extends string>(
-    searchValue: S,
-    replaceValue: D,
-  ): sl.tuple.TupleWithReplace<Tuple, S, D, [], true> extends infer W extends
-    readonly string[]
-    ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
-    : never;
-
-  withTrim(): sl.tuple.TupleWithTrim<Tuple, []> extends infer W extends
-    readonly string[]
-    ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
-    : never;
-  toLowerCase(): sl.tuple.TupleWithCaseTransform<
-    Tuple,
-    'lowercase',
-    []
-  > extends infer W extends readonly string[]
-    ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
-    : never;
-  toUpperCase(): sl.tuple.TupleWithCaseTransform<
-    Tuple,
-    'uppercase',
-    []
-  > extends infer W extends readonly string[]
-    ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
-    : never;
-  toCapitalize(): sl.tuple.TupleWithCaseTransform<
-    Tuple,
-    'capitalize',
-    []
-  > extends infer W extends readonly string[]
-    ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
-    : never;
-  toUnCapitalize(): sl.tuple.TupleWithCaseTransform<
-    Tuple,
-    'unCapitalize',
-    []
-  > extends infer W extends readonly string[]
-    ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
-    : never;
-
-  value(val): Tuple[number];
-  mutable(): (Tuple[number] & string)[];
-  sort<P1 = Tuple[number], P2 = Tuple[number]>(
-    compareFn?: (a: P1, b: P2) => number,
-  ): MaybeReadonly<Mut, IStringList<Tuple, Mut, true>>;
-
-  reverse(): sl.tuple.TupleReversed<Tuple, []> extends infer W extends
-    readonly string[]
-    ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
-    : this;
-
-  without<S extends string>(
-    ...arg: readonly (ILiterals<readonly S[]> | S)[]
-  ): sl.tuple.TupleWithExclude<Tuple, S, []> extends infer E extends
-    readonly string[]
-    ? MaybeReadonly<Mut, IStringList<E, Mut, Unsorted>>
-    : never;
-
-  toSorted(
-    compareFn?: (a: Tuple[number], b: Tuple[number]) => number,
-  ): MaybeReadonly<Mut, IStringList<Tuple, Mut, true>>;
-
-  toReversed(): sl.tuple.TupleReversed<Tuple, []> extends infer W extends
-    readonly string[]
-    ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
-    : never;
-
-  /**
-   * @deprecated This method does not support type inference,
-   * use `list.concat('str', 'str')` or `list.concatList(stringList('str','str'))` instead.
-   */
-  concat<S extends readonly string[]>(
-    ...arg: S[]
-  ): [...Tuple, S[number][number]] extends infer W extends readonly string[]
-    ? MaybeReadonly<Mut, IStringList<W, Mut, true>>
-    : never;
-
-  concat<S extends readonly string[]>(
-    ...arg: S
-  ): [...Tuple, ...S] extends infer W extends readonly string[]
-    ? MaybeReadonly<
-        Mut,
-        IStringList<W, Mut, [Tuple] extends [[]] ? false : Unsorted>
-      >
-    : never;
-
-  concatList<S extends readonly string[]>(
-    arg: ILiterals<S>,
-  ): S extends infer C extends readonly string[]
-    ? readonly [...Tuple, ...C] extends infer W extends readonly string[]
-      ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
-      : this
-    : this;
-
-  toRecordType<
-    RT extends RecordType = 'any',
-    R extends Record<string, unknown>[] = [],
-  >(
-    type?: RT,
-    initial?: RecordTypes[RT],
-    ...records: R
-  ): sl.record.Merge<[Record<Tuple[number], RecordTypes[RT]>, ...R]>;
-
-  toRecordValue<V extends unknown = any, R extends any[] = never>(
-    initial?: V,
-    ...records: R
-  ): R[number] extends never
-    ? Record<Tuple[number], V>
-    : sl.record.Merge<[Record<Tuple[number], V>, ...R]>;
-
-  // Readonly overrides
-  readonly length: [Unsorted] extends [true] ? number : Tuple['length'];
-  readonly [n: number]: Tuple[number] | undefined;
-  readonly enum: { [P in Tuple[number]]: P } & { [P: string]: Tuple[number] };
-
-  // Supported Methods
-  at(n: number): Tuple[number] | undefined;
-
-  // Type override to prevent string not in type T issue
-  includes<PP = Tuple[number]>(val: PP, fromIndex?: number): boolean;
-  indexOf<PP = Tuple[number]>(searchElement: PP, fromIndex?: number): number;
-  lastIndexOf<PP = Tuple[number]>(
-    searchElement: PP,
-    fromIndex?: number,
-  ): number;
-
-  find<PP = Tuple[number] & string>(
-    predictate: (
-      val: PP extends Tuple[number] & string ? Tuple[number] : PP,
-      i: number,
-      obj: Tuple[number][],
-    ) => val is PP extends Tuple[number] & string ? Tuple[number] : PP,
-  ): Tuple[number];
-  find(
-    predictate: (
-      val: string | undefined,
-      i: number,
-      obj: Tuple[number][],
-    ) => boolean,
-  ): Tuple[number];
-  findIndex<S = Tuple[number] & string>(
-    predicate: (
-      value: S & string,
-      index: number,
-      obj: Tuple[number][],
-    ) => unknown,
-    thisArg?: any,
-  ): number;
-
-  slice<Start extends number = 0, End extends number = Tuple['length']>(
-    start?: Start,
-    end?: End,
-  ): [[Start], [End]] extends [[0 | never], [Tuple['length'] | never]]
-    ? this
-    : sl.tuple.TupleSlice<
-          Tuple,
-          sl.tuple.GetTuplePositiveIndex<Tuple, Start>,
-          sl.tuple.GetTuplePositiveIndex<Tuple, End>
-        > extends infer W extends readonly string[]
-      ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
-      : never;
-
-  toSpliced<Start extends number = 0>(
-    start: Start,
-  ): [Start] extends [0 | never]
-    ? MaybeReadonly<Mut, IStringList<[], Mut, Unsorted>>
-    : [sl.generic.IsNegative<Start>] extends [true]
-      ? MaybeReadonly<Mut, IStringList<Tuple, Mut, Unsorted>>
-      : sl.tuple.TupleSplit<Tuple, Start> extends readonly [infer C, infer R]
-        ? C extends readonly string[]
-          ? R extends readonly string[]
-            ? MaybeReadonly<Mut, IStringList<C, Mut, Unsorted>>
-            : never
+        ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
+        : never;
+
+      withSuffix<P extends string>(
+        suffix: P,
+      ): P extends string
+        ? StringLiteralList.tuple.TupleSuffixed<
+            Tuple,
+            P extends string ? P : '',
+            []
+          > extends infer W extends readonly string[]
+          ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
           : never
         : never;
 
-  toSpliced<Start extends number, DelCount extends number>(
-    start: Start,
-    deleteCount: DelCount,
-  ): [
-    sl.generic.IsNegative<
-      sl.generic.Subtract<
-        sl.generic.Subtract<
-          Tuple['length'],
-          [sl.generic.IsNegative<Start>] extends [true] ? 0 : Start
+      // withDerivatedSuffix<S extends string>(
+      //   chars: S,
+      // ):
+      //   | T
+      //   | StringLiteralList.string.DropSuffix<
+      //       StringLiteralList.string.DropSuffix<`${T}${S}${S}`, S>,
+      //       `${S}${S}`
+      //     > extends infer W extends string
+      //   ? MaybeReadonly<Mut, IStringList<W, readonly W[], Mut, true>>
+      //   : never;
+
+      // withDerivatedPrefix<S extends string>(
+      //   chars: S,
+      // ):
+      //   | T
+      //   | StringLiteralList.string.DropPrefix<
+      //       StringLiteralList.string.DropPrefix<`${S}${S}${T}`, S>,
+      //       `${S}${S}`
+      //     > extends infer W extends string
+      //   ? MaybeReadonly<Mut, IStringList<W, readonly W[], Mut, true>>
+      //   : never;
+
+      withReplace<S extends string, D extends string>(
+        searchValue: S,
+        replaceValue: D,
+      ): StringLiteralList.tuple.TupleWithReplace<
+        Tuple,
+        S,
+        D,
+        [],
+        false
+      > extends infer W extends readonly string[]
+        ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
+        : never;
+
+      withReplaceAll<S extends string | RegExp, D extends string>(
+        searchValue: S,
+        replaceValue: D,
+      ): StringLiteralList.tuple.TupleWithReplace<
+        Tuple,
+        S,
+        D,
+        [],
+        true
+      > extends infer W extends readonly string[]
+        ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
+        : never;
+
+      withTrim(): StringLiteralList.tuple.TupleWithTrim<
+        Tuple,
+        []
+      > extends infer W extends readonly string[]
+        ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
+        : never;
+      toLowerCase(): StringLiteralList.tuple.TupleWithCaseTransform<
+        Tuple,
+        'lowercase',
+        []
+      > extends infer W extends readonly string[]
+        ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
+        : never;
+      toUpperCase(): StringLiteralList.tuple.TupleWithCaseTransform<
+        Tuple,
+        'uppercase',
+        []
+      > extends infer W extends readonly string[]
+        ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
+        : never;
+      toCapitalize(): StringLiteralList.tuple.TupleWithCaseTransform<
+        Tuple,
+        'capitalize',
+        []
+      > extends infer W extends readonly string[]
+        ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
+        : never;
+      toUnCapitalize(): StringLiteralList.tuple.TupleWithCaseTransform<
+        Tuple,
+        'unCapitalize',
+        []
+      > extends infer W extends readonly string[]
+        ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
+        : never;
+
+      value(val): Tuple[number];
+      mutable(): (Tuple[number] & string)[];
+      sort<P1 = Tuple[number], P2 = Tuple[number]>(
+        compareFn?: (a: P1, b: P2) => number,
+      ): MaybeReadonly<Mut, IStringList<Tuple, Mut, true>>;
+
+      reverse(): StringLiteralList.tuple.TupleReversed<
+        Tuple,
+        []
+      > extends infer W extends readonly string[]
+        ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
+        : this;
+
+      without<S extends string>(
+        ...arg: readonly (ILiterals<readonly S[]> | S)[]
+      ): StringLiteralList.tuple.TupleWithExclude<
+        Tuple,
+        S,
+        []
+      > extends infer E extends readonly string[]
+        ? MaybeReadonly<Mut, IStringList<E, Mut, Unsorted>>
+        : never;
+
+      toSorted(
+        compareFn?: (a: Tuple[number], b: Tuple[number]) => number,
+      ): MaybeReadonly<Mut, IStringList<Tuple, Mut, true>>;
+
+      toReversed(): StringLiteralList.tuple.TupleReversed<
+        Tuple,
+        []
+      > extends infer W extends readonly string[]
+        ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
+        : never;
+
+      /**
+       * @deprecated This method does not support type inference,
+       * use `list.concat('str', 'str')` or `list.concatList(stringList('str','str'))` instead.
+       */
+      concat<S extends readonly string[]>(
+        ...arg: S[]
+      ): [...Tuple, S[number][number]] extends infer W extends readonly string[]
+        ? MaybeReadonly<Mut, IStringList<W, Mut, true>>
+        : never;
+
+      concat<S extends readonly string[]>(
+        ...arg: S
+      ): [...Tuple, ...S] extends infer W extends readonly string[]
+        ? MaybeReadonly<
+            Mut,
+            IStringList<W, Mut, [Tuple] extends [[]] ? false : Unsorted>
+          >
+        : never;
+
+      concatList<S extends readonly string[]>(
+        arg: ILiterals<S>,
+      ): S extends infer C extends readonly string[]
+        ? readonly [...Tuple, ...C] extends infer W extends readonly string[]
+          ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
+          : this
+        : this;
+
+      toRecordType<
+        RT extends RecordType = 'any',
+        R extends Record<string, unknown>[] = [],
+      >(
+        type?: RT,
+        initial?: RecordTypes[RT],
+        ...records: R
+      ): StringLiteralList.record.Merge<
+        [Record<Tuple[number], RecordTypes[RT]>, ...R]
+      >;
+
+      toRecordValue<V extends unknown = any, R extends any[] = never>(
+        initial?: V,
+        ...records: R
+      ): R[number] extends never
+        ? Record<Tuple[number], V>
+        : StringLiteralList.record.Merge<[Record<Tuple[number], V>, ...R]>;
+
+      // Readonly overrides
+      readonly length: [Unsorted] extends [true] ? number : Tuple['length'];
+      readonly [n: number]: Tuple[number] | undefined;
+      readonly enum: { [P in Tuple[number]]: P } & {
+        [P: string]: Tuple[number];
+      };
+
+      // Supported Methods
+      at(n: number): Tuple[number] | undefined;
+
+      // Type override to prevent string not in type T issue
+      includes<PP = Tuple[number]>(val: PP, fromIndex?: number): boolean;
+      indexOf<PP = Tuple[number]>(
+        searchElement: PP,
+        fromIndex?: number,
+      ): number;
+      lastIndexOf<PP = Tuple[number]>(
+        searchElement: PP,
+        fromIndex?: number,
+      ): number;
+
+      find<PP = Tuple[number] & string>(
+        predictate: (
+          val: PP extends Tuple[number] & string ? Tuple[number] : PP,
+          i: number,
+          obj: Tuple[number][],
+        ) => val is PP extends Tuple[number] & string ? Tuple[number] : PP,
+      ): Tuple[number];
+      find(
+        predictate: (
+          val: string | undefined,
+          i: number,
+          obj: Tuple[number][],
+        ) => boolean,
+      ): Tuple[number];
+      findIndex<S = Tuple[number] & string>(
+        predicate: (
+          value: S & string,
+          index: number,
+          obj: Tuple[number][],
+        ) => unknown,
+        thisArg?: any,
+      ): number;
+
+      slice<Start extends number = 0, End extends number = Tuple['length']>(
+        start?: Start,
+        end?: End,
+      ): [[Start], [End]] extends [[0 | never], [Tuple['length'] | never]]
+        ? this
+        : StringLiteralList.tuple.TupleSlice<
+              Tuple,
+              StringLiteralList.tuple.GetTuplePositiveIndex<Tuple, Start>,
+              StringLiteralList.tuple.GetTuplePositiveIndex<Tuple, End>
+            > extends infer W extends readonly string[]
+          ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
+          : never;
+
+      toSpliced<Start extends number = 0>(
+        start: Start,
+      ): [Start] extends [0 | never]
+        ? MaybeReadonly<Mut, IStringList<[], Mut, Unsorted>>
+        : [StringLiteralList.generic.IsNegative<Start>] extends [true]
+          ? MaybeReadonly<Mut, IStringList<Tuple, Mut, Unsorted>>
+          : StringLiteralList.tuple.TupleSplit<Tuple, Start> extends readonly [
+                infer C,
+                infer R,
+              ]
+            ? C extends readonly string[]
+              ? R extends readonly string[]
+                ? MaybeReadonly<Mut, IStringList<C, Mut, Unsorted>>
+                : never
+              : never
+            : never;
+
+      toSpliced<Start extends number, DelCount extends number>(
+        start: Start,
+        deleteCount: DelCount,
+      ): [
+        StringLiteralList.generic.IsNegative<
+          StringLiteralList.generic.Subtract<
+            StringLiteralList.generic.Subtract<
+              Tuple['length'],
+              [StringLiteralList.generic.IsNegative<Start>] extends [true]
+                ? 0
+                : Start
+            >,
+            1
+          >
         >,
-        1
-      >
-    >,
-  ] extends [true]
-    ? this
-    : [
-          [
-            sl.generic.IsNegative<
-              sl.generic.Subtract<
-                sl.generic.Subtract<
-                  Tuple['length'],
-                  [DelCount] extends [number] ? DelCount : 0
+      ] extends [true]
+        ? this
+        : [
+              [
+                StringLiteralList.generic.IsNegative<
+                  StringLiteralList.generic.Subtract<
+                    StringLiteralList.generic.Subtract<
+                      Tuple['length'],
+                      [DelCount] extends [number] ? DelCount : 0
+                    >,
+                    1
+                  >
                 >,
-                1
-              >
+              ],
+              [Start],
+              [DelCount],
+            ] extends
+              | [[true], [0], [any]]
+              | [[any], [0], [Tuple['length']]]
+              | [[any], [0], [never]]
+          ? MaybeReadonly<Mut, IStringList<[], Mut, false>>
+          : StringLiteralList.tuple.TupleSplit<
+                Tuple,
+                [StringLiteralList.generic.IsNegative<Start>] extends [true]
+                  ? 0
+                  : Start
+              > extends readonly [infer C, infer R]
+            ? C extends readonly string[]
+              ? R extends readonly string[]
+                ? StringLiteralList.tuple.TupleSplit<
+                    R,
+                    DelCount
+                  > extends readonly [infer D, infer E]
+                  ? E extends readonly string[]
+                    ? MaybeReadonly<
+                        Mut,
+                        IStringList<readonly [...C, ...E], Mut, Unsorted>
+                      >
+                    : MaybeReadonly<Mut, IStringList<C, Mut, Unsorted>>
+                  : MaybeReadonly<Mut, IStringList<C, Mut, Unsorted>>
+                : never
+              : never
+            : never;
+
+      toSpliced<
+        Start extends number,
+        DelCount extends number,
+        I extends string[],
+      >(
+        start: Start,
+        deleteCount: DelCount,
+        ...items: I
+      ): [
+        StringLiteralList.generic.IsNegative<
+          StringLiteralList.generic.Subtract<
+            StringLiteralList.generic.Subtract<
+              Tuple['length'],
+              [StringLiteralList.generic.IsNegative<Start>] extends [true]
+                ? 0
+                : Start
             >,
-          ],
-          [Start],
-          [DelCount],
-        ] extends
-          | [[true], [0], [any]]
-          | [[any], [0], [Tuple['length']]]
-          | [[any], [0], [never]]
-      ? MaybeReadonly<Mut, IStringList<[], Mut, false>>
-      : sl.tuple.TupleSplit<
-            Tuple,
-            [sl.generic.IsNegative<Start>] extends [true] ? 0 : Start
-          > extends readonly [infer C, infer R]
-        ? C extends readonly string[]
-          ? R extends readonly string[]
-            ? sl.tuple.TupleSplit<R, DelCount> extends readonly [
-                infer D,
-                infer E,
-              ]
-              ? E extends readonly string[]
-                ? MaybeReadonly<
+            1
+          >
+        >,
+      ] extends [true]
+        ? readonly [...Tuple, ...I] extends infer W extends readonly string[]
+          ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
+          : never
+        : StringLiteralList.tuple.TupleSplit<
+              Tuple,
+              StringLiteralList.tuple.GetTuplePositiveIndex<Tuple, Start>
+            > extends readonly [infer C, infer R]
+          ? C extends readonly string[]
+            ? R extends readonly string[]
+              ? StringLiteralList.tuple.TupleSplit<
+                  R,
+                  [StringLiteralList.generic.IsNegative<DelCount>] extends [
+                    true,
+                  ]
+                    ? 0
+                    : DelCount
+                > extends readonly [infer D, infer E]
+                ? E extends readonly string[]
+                  ? MaybeReadonly<
+                      Mut,
+                      IStringList<readonly [...C, ...I, ...E], Mut, Unsorted>
+                    >
+                  : MaybeReadonly<
+                      Mut,
+                      IStringList<readonly [...C, ...I], Mut, Unsorted>
+                    >
+                : MaybeReadonly<
                     Mut,
-                    IStringList<readonly [...C, ...E], Mut, Unsorted>
+                    IStringList<readonly [...I, ...C], Mut, Unsorted>
                   >
-                : MaybeReadonly<Mut, IStringList<C, Mut, Unsorted>>
-              : MaybeReadonly<Mut, IStringList<C, Mut, Unsorted>>
+              : never
             : never
-          : never
-        : never;
-
-  toSpliced<Start extends number, DelCount extends number, I extends string[]>(
-    start: Start,
-    deleteCount: DelCount,
-    ...items: I
-  ): [
-    sl.generic.IsNegative<
-      sl.generic.Subtract<
-        sl.generic.Subtract<
-          Tuple['length'],
-          [sl.generic.IsNegative<Start>] extends [true] ? 0 : Start
-        >,
-        1
-      >
-    >,
-  ] extends [true]
-    ? readonly [...Tuple, ...I] extends infer W extends readonly string[]
-      ? MaybeReadonly<Mut, IStringList<W, Mut, Unsorted>>
-      : never
-    : sl.tuple.TupleSplit<
-          Tuple,
-          sl.tuple.GetTuplePositiveIndex<Tuple, Start>
-        > extends readonly [infer C, infer R]
-      ? C extends readonly string[]
-        ? R extends readonly string[]
-          ? sl.tuple.TupleSplit<
-              R,
-              [sl.generic.IsNegative<DelCount>] extends [true] ? 0 : DelCount
-            > extends readonly [infer D, infer E]
-            ? E extends readonly string[]
-              ? MaybeReadonly<
-                  Mut,
-                  IStringList<readonly [...C, ...I, ...E], Mut, Unsorted>
-                >
-              : MaybeReadonly<
-                  Mut,
-                  IStringList<readonly [...C, ...I], Mut, Unsorted>
-                >
-            : MaybeReadonly<
-                Mut,
-                IStringList<readonly [...I, ...C], Mut, Unsorted>
-              >
-          : never
-        : never
-      : never;
-
-  some<S = Tuple[number] & string>(
-    predicate: (
-      value: S & string,
-      index: number,
-      array: Tuple[number][],
-    ) => unknown,
-    thisArg?: any,
-  ): boolean;
-  every<S = Tuple[number] & string>(
-    predicate: (
-      value: S & string,
-      index: number,
-      array: Tuple[number][],
-    ) => value is S & string,
-    thisArg?: any,
-  ): this is S[];
-  every(
-    predicate: (
-      value: Tuple[number] & string,
-      index: number,
-      array: Tuple[number][],
-    ) => unknown,
-    thisArg?: any,
-  ): boolean;
-
-  // Return Type overrides
-  /**
-   * @deprecated This method does not support type inference and will return a mutable T[] array.
-   */
-  with<V extends string>(index: number, value: V): (Tuple[number] | V)[];
-  filter<S = Tuple[number] & string>(
-    predicate: (
-      value: S & string,
-      index: number,
-      array: Tuple[number][],
-    ) => value is S & string,
-    thisArg?: any,
-  ): S[];
-  filter(
-    predicate: (
-      value: string,
-      index: number,
-      array: Tuple[number][],
-    ) => boolean,
-    thisArg?: any,
-  ): (Tuple[number] & string)[];
-
-  /**
-   * @deprecated This method will mutate the list, Get the mutable array with `list.mutable()`
-   * Or to obtain a modified list without the last element use:
-   * `const lastElement = list[list.length - 1]` and then remove it using `const newlist = list.without(lastElement)`.
-   */
-  pop(): Tuple[number] | undefined;
-
-  /**
-   * @deprecated This method will mutate the list, get the mutable array with `list.mutable()`
-   * Or use `const firstElement = list[0]` and then remove it using `const newlist = list.without(firstElement)`.
-   */
-  shift(): Tuple[number] | undefined;
-
-  /**
-   * @deprecated This method will mutate the list, get the mutable array with `list.mutable()`
-   * Or use `const newlist = stringList('el', list);`.
-   */
-  unshift<S = Tuple[number] & string>(...newElement: S[]): number;
-
-  /**
-   * @deprecated This method will mutate the list, use `list.concat()` or get the mutable array with `list.mutable()`
-   */
-  push<S = Tuple[number] & string>(...items: S[]): number;
-
-  /**
-   * @deprecated This method will mutate the list, get the mutable array with `list.mutable()`
-   * Or to obtain a modified list use:
-   * `list.toSpliced())`.
-   */
-  splice(start: number, deleteCount?: number): Tuple[number][];
-
-  /**
-   * @deprecated This method will mutate the list, get the mutable array with `list.mutable()`
-   * Or to obtain a modified list use:
-   * `list.toSpliced())`.
-   */
-  splice<Items extends string[] = []>(
-    start: number,
-    deleteCount: number,
-    ...items: Items
-  ): Tuple[number][];
-
-  /**
-   * @deprecated This method will mutate the list, get the mutable array with `list.mutable()`
-   */
-  copyWithin<S = Tuple[number] & string>(
-    target: number,
-    start: number,
-    end?: number,
-  ): S[];
-  /**
-   * @deprecated This method will mutate the list, get the mutable array with `list.mutable()`
-   */
-  fill<S = Tuple[number], U = Tuple[number] & string>(
-    value: (U | undefined)[],
-    start?: number,
-    end?: number,
-  ): U[];
-  /**
-   * @deprecated This method will mutate the list, get the mutable array with `list.mutable()`
-   */
-  fill<U = Tuple[number] & string>(value: U, start?: number, end?: number): U[];
-  join<D extends string = ''>(
-    delimiter?: D,
-  ): [this['infered']['TooLong']] extends [true]
-    ? string
-    : [Unsorted] extends [true]
-      ? [Tuple['length']] extends [0]
-        ? ''
-        : string
-      : [Tuple['length']] extends [0]
-        ? ''
-        : sl.tuple.TupleSplit<Tuple, 100> extends readonly [
-              infer A extends readonly string[],
-              infer B,
-            ]
-          ? B extends readonly string[]
-            ? `${sl.tuple.Join<B, D>}` extends infer C extends string
-              ? C extends ''
-                ? `${sl.tuple.Join<A, D>}`
-                : `${sl.tuple.Join<A, D>}${D}${C}`
-              : sl.tuple.Join<A, D>
-            : sl.tuple.Join<Tuple, D>
-          : string;
+          : never;
+
+      some<S = Tuple[number] & string>(
+        predicate: (
+          value: S & string,
+          index: number,
+          array: Tuple[number][],
+        ) => unknown,
+        thisArg?: any,
+      ): boolean;
+      every<S = Tuple[number] & string>(
+        predicate: (
+          value: S & string,
+          index: number,
+          array: Tuple[number][],
+        ) => value is S & string,
+        thisArg?: any,
+      ): this is S[];
+      every(
+        predicate: (
+          value: Tuple[number] & string,
+          index: number,
+          array: Tuple[number][],
+        ) => unknown,
+        thisArg?: any,
+      ): boolean;
+
+      // Return Type overrides
+      /**
+       * @deprecated This method does not support type inference and will return a mutable T[] array.
+       */
+      with<V extends string>(index: number, value: V): (Tuple[number] | V)[];
+      filter<S = Tuple[number] & string>(
+        predicate: (
+          value: S & string,
+          index: number,
+          array: Tuple[number][],
+        ) => value is S & string,
+        thisArg?: any,
+      ): S[];
+      filter(
+        predicate: (
+          value: string,
+          index: number,
+          array: Tuple[number][],
+        ) => boolean,
+        thisArg?: any,
+      ): (Tuple[number] & string)[];
+
+      /**
+       * @deprecated This method will mutate the list, Get the mutable array with `list.mutable()`
+       * Or to obtain a modified list without the last element use:
+       * `const lastElement = list[list.length - 1]` and then remove it using `const newlist = list.without(lastElement)`.
+       */
+      pop(): Tuple[number] | undefined;
+
+      /**
+       * @deprecated This method will mutate the list, get the mutable array with `list.mutable()`
+       * Or use `const firstElement = list[0]` and then remove it using `const newlist = list.without(firstElement)`.
+       */
+      shift(): Tuple[number] | undefined;
+
+      /**
+       * @deprecated This method will mutate the list, get the mutable array with `list.mutable()`
+       * Or use `const newlist = stringList('el', list);`.
+       */
+      unshift<S = Tuple[number] & string>(...newElement: S[]): number;
+
+      /**
+       * @deprecated This method will mutate the list, use `list.concat()` or get the mutable array with `list.mutable()`
+       */
+      push<S = Tuple[number] & string>(...items: S[]): number;
+
+      /**
+       * @deprecated This method will mutate the list, get the mutable array with `list.mutable()`
+       * Or to obtain a modified list use:
+       * `list.toSpliced())`.
+       */
+      splice(start: number, deleteCount?: number): Tuple[number][];
+
+      /**
+       * @deprecated This method will mutate the list, get the mutable array with `list.mutable()`
+       * Or to obtain a modified list use:
+       * `list.toSpliced())`.
+       */
+      splice<Items extends string[] = []>(
+        start: number,
+        deleteCount: number,
+        ...items: Items
+      ): Tuple[number][];
+
+      /**
+       * @deprecated This method will mutate the list, get the mutable array with `list.mutable()`
+       */
+      copyWithin<S = Tuple[number] & string>(
+        target: number,
+        start: number,
+        end?: number,
+      ): S[];
+      /**
+       * @deprecated This method will mutate the list, get the mutable array with `list.mutable()`
+       */
+      fill<S = Tuple[number], U = Tuple[number] & string>(
+        value: (U | undefined)[],
+        start?: number,
+        end?: number,
+      ): U[];
+      /**
+       * @deprecated This method will mutate the list, get the mutable array with `list.mutable()`
+       */
+      fill<U = Tuple[number] & string>(
+        value: U,
+        start?: number,
+        end?: number,
+      ): U[];
+      join<D extends string = ''>(
+        delimiter?: D,
+      ): [this['infered']['TooLong']] extends [true]
+        ? string
+        : [Unsorted] extends [true]
+          ? [Tuple['length']] extends [0]
+            ? ''
+            : string
+          : [Tuple['length']] extends [0]
+            ? ''
+            : StringLiteralList.tuple.TupleSplit<Tuple, 100> extends readonly [
+                  infer A extends readonly string[],
+                  infer B,
+                ]
+              ? B extends readonly string[]
+                ? `${StringLiteralList.tuple.Join<B, D>}` extends infer C extends
+                    string
+                  ? C extends ''
+                    ? `${StringLiteralList.tuple.Join<A, D>}`
+                    : `${StringLiteralList.tuple.Join<A, D>}${D}${C}`
+                  : StringLiteralList.tuple.Join<A, D>
+                : StringLiteralList.tuple.Join<Tuple, D>
+              : string;
+    }
+  }
 }
-
 export {};
diff --git a/types/record.d.ts b/types/record.d.ts
index 14cb1a4..8e59f17 100644
--- a/types/record.d.ts
+++ b/types/record.d.ts
@@ -1,22 +1,20 @@
 declare global {
-  export namespace StringLiteralList {
-    export namespace record {
-      export type StringRecord<T extends string, S extends unknown> = Record<
-        T,
-        S
-      >;
+  export namespace StringLiteralList {}
+  export namespace StringLiteralList.record {
+    export type StringRecord<T extends string, S extends unknown> = Record<
+      T,
+      S
+    >;
 
-      export type Merge<Records extends Record<string, any>[]> =
-        Records extends [
-          infer A extends Record<string, any>,
-          infer B extends Record<string, any>,
-          ...infer Rest extends Record<string, any>[],
-        ]
-          ? Merge<[A & Omit<B, keyof A>, ...Rest]>
-          : Records extends [infer A]
-            ? A
-            : unknown;
-    }
+    export type Merge<Records extends Record<string, any>[]> = Records extends [
+      infer A extends Record<string, any>,
+      infer B extends Record<string, any>,
+      ...infer Rest extends Record<string, any>[],
+    ]
+      ? Merge<[A & Omit<B, keyof A>, ...Rest]>
+      : Records extends [infer A]
+        ? A
+        : unknown;
   }
 }
 
diff --git a/types/string.d.ts b/types/string.d.ts
index fa45ed0..c021e4c 100644
--- a/types/string.d.ts
+++ b/types/string.d.ts
@@ -3,143 +3,142 @@
 /// <reference path="tuple.d.ts" />
 
 declare global {
-  export namespace StringLiteralList {
-    export namespace string {
-      /**
-       * @credit @gustavoguichard
-       * For the string manipulation types,
-       * borrowed and adapted from the library string-ts
-       */
+  export namespace StringLiteralList {}
+  export namespace StringLiteralList.string {
+    /**
+     * @credit @gustavoguichard
+     * For the string manipulation types,
+     * borrowed and adapted from the library string-ts
+     */
 
-      type GetStringPositiveIndex<T extends string, I extends number> =
-        generic.IsNegative<I> extends false
-          ? I
-          : generic.Subtract<Length<T>, generic.Abs<I>>;
+    export type GetStringPositiveIndex<T extends string, I extends number> =
+      generic.IsNegative<I> extends false
+        ? I
+        : generic.Subtract<Length<T>, generic.Abs<I>>;
 
-      type IsStringLiteral<T extends string> = [T] extends [string]
-        ? [string] extends [T]
-          ? false
-          : Uppercase<T> extends Uppercase<Lowercase<T>>
-            ? Lowercase<T> extends Lowercase<Uppercase<T>>
-              ? true
-              : false
+    export type IsStringLiteral<T extends string> = [T] extends [string]
+      ? [string] extends [T]
+        ? false
+        : Uppercase<T> extends Uppercase<Lowercase<T>>
+          ? Lowercase<T> extends Lowercase<Uppercase<T>>
+            ? true
             : false
-        : false;
+          : false
+      : false;
 
-      export type Split<T extends string, delimiter extends string = ''> =
-        IsStringLiteral<T | delimiter> extends true
-          ? T extends `${infer first}${delimiter}${infer rest}`
-            ? [first, ...Split<rest, delimiter>]
-            : T extends ''
-              ? []
-              : [T]
-          : string[];
+    export type Split<T extends string, delimiter extends string = ''> =
+      IsStringLiteral<T | delimiter> extends true
+        ? T extends `${infer first}${delimiter}${infer rest}`
+          ? [first, ...Split<rest, delimiter>]
+          : T extends ''
+            ? []
+            : [T]
+        : string[];
 
-      type Length<T extends string> =
-        IsStringLiteral<T> extends true ? Split<T>['length'] : number;
+    export type Length<T extends string> =
+      IsStringLiteral<T> extends true ? Split<T>['length'] : number;
 
-      export type StringConcat<
-        T1 extends string | number | bigint | boolean,
-        T2 extends string | number | bigint | boolean,
-      > = `${T1}${T2}`;
+    export type StringConcat<
+      T1 extends string | number | bigint | boolean,
+      T2 extends string | number | bigint | boolean,
+    > = `${T1}${T2}`;
 
-      type CaseTransform<
-        T extends string,
-        Transform extends
-          | 'uppercase'
-          | 'lowercase'
-          | 'capitalize'
-          | 'unCapitalize',
-      > = Transform extends 'uppercase'
-        ? Uppercase<T>
-        : Transform extends 'lowercase'
-          ? Lowercase<T>
-          : Transform extends 'capitalize'
+    export type CaseTransform<
+      T extends string,
+      Transform extends
+        | 'uppercase'
+        | 'lowercase'
+        | 'capitalize'
+        | 'unCapitalize',
+    > = Transform extends 'uppercase'
+      ? Uppercase<T>
+      : Transform extends 'lowercase'
+        ? Lowercase<T>
+        : Transform extends 'capitalize'
+          ? Split<T, ' '> extends [
+              infer U extends string,
+              ...infer Rest extends string[],
+            ]
+            ? U extends string
+              ? [Rest['length']] extends [0]
+                ? Capitalize<U>
+                : Rest extends readonly string[]
+                  ? `${Capitalize<U>} ${tuple.Join<tuple.TupleWithCaseTransform<Rest, 'capitalize', []>, ' '>}`
+                  : T
+              : T
+            : T
+          : Transform extends 'unCapitalize'
             ? Split<T, ' '> extends [
                 infer U extends string,
                 ...infer Rest extends string[],
               ]
               ? U extends string
                 ? [Rest['length']] extends [0]
-                  ? Capitalize<U>
+                  ? Uncapitalize<U>
                   : Rest extends readonly string[]
-                    ? `${Capitalize<U>} ${tuple.Join<tuple.TupleWithCaseTransform<Rest, 'capitalize', []>, ' '>}`
+                    ? `${Uncapitalize<U>} ${tuple.Join<tuple.TupleWithCaseTransform<Rest, 'unCapitalize', []>, ' '>}`
                     : T
                 : T
               : T
-            : Transform extends 'unCapitalize'
-              ? Split<T, ' '> extends [
-                  infer U extends string,
-                  ...infer Rest extends string[],
-                ]
-                ? U extends string
-                  ? [Rest['length']] extends [0]
-                    ? Uncapitalize<U>
-                    : Rest extends readonly string[]
-                      ? `${Uncapitalize<U>} ${tuple.Join<tuple.TupleWithCaseTransform<Rest, 'unCapitalize', []>, ' '>}`
-                      : T
-                  : T
-                : T
-              : T;
+            : T;
 
-      export type DropSuffix<
-        sentence extends string,
-        suffix extends string,
-      > = string extends sentence | suffix
-        ? string
-        : sentence extends `${infer rest}${suffix}`
-          ? rest
-          : sentence;
+    export type DropSuffix<
+      sentence extends string,
+      suffix extends string,
+    > = string extends sentence | suffix
+      ? string
+      : sentence extends `${infer rest}${suffix}`
+        ? rest
+        : sentence;
 
-      export type DropPrefix<
-        sentence extends string,
-        prefix extends string,
-      > = string extends sentence | prefix
-        ? string
-        : sentence extends `${prefix}${infer rest}`
-          ? rest
-          : sentence;
+    export type DropPrefix<
+      sentence extends string,
+      prefix extends string,
+    > = string extends sentence | prefix
+      ? string
+      : sentence extends `${prefix}${infer rest}`
+        ? rest
+        : sentence;
 
-      type TrimStart<T extends string> =
-        IsStringLiteral<T> extends true
-          ? T extends ` ${infer rest}`
-            ? TrimStart<rest>
-            : T
-          : string;
+    export type TrimStart<T extends string> =
+      IsStringLiteral<T> extends true
+        ? T extends ` ${infer rest}`
+          ? TrimStart<rest>
+          : T
+        : string;
 
-      type TrimEnd<T extends string> =
-        IsStringLiteral<T> extends true
-          ? T extends `${infer rest} `
-            ? TrimEnd<rest>
-            : T
-          : string;
+    export type TrimEnd<T extends string> =
+      IsStringLiteral<T> extends true
+        ? T extends `${infer rest} `
+          ? TrimEnd<rest>
+          : T
+        : string;
 
-      export type Trim<T extends string> = TrimEnd<TrimStart<T>>;
+    export type Trim<T extends string> = TrimEnd<TrimStart<T>>;
 
-      export type Replace<
-        sentence extends string,
-        lookup extends string | RegExp,
-        replacement extends string = '',
-      > = lookup extends string
-        ? IsStringLiteral<lookup | sentence | replacement> extends true
-          ? sentence extends `${infer rest}${lookup}${infer rest2}`
-            ? `${rest}${replacement}${rest2}`
-            : sentence
-          : string
-        : string;
+    export type Replace<
+      sentence extends string,
+      lookup extends string | RegExp,
+      replacement extends string = '',
+    > = lookup extends string
+      ? IsStringLiteral<lookup | sentence | replacement> extends true
+        ? sentence extends `${infer rest}${lookup}${infer rest2}`
+          ? `${rest}${replacement}${rest2}`
+          : sentence
+        : string
+      : string;
 
-      type ReplaceAll<
-        sentence extends string,
-        lookup extends string | RegExp,
-        replacement extends string = '',
-      > = lookup extends string
-        ? IsStringLiteral<lookup | sentence | replacement> extends true
-          ? sentence extends `${infer rest}${lookup}${infer rest2}`
-            ? `${rest}${replacement}${ReplaceAll<rest2, lookup, replacement>}`
-            : sentence
-          : string
-        : string;
-    }
+    export type ReplaceAll<
+      sentence extends string,
+      lookup extends string | RegExp,
+      replacement extends string = '',
+    > = lookup extends string
+      ? IsStringLiteral<lookup | sentence | replacement> extends true
+        ? sentence extends `${infer rest}${lookup}${infer rest2}`
+          ? `${rest}${replacement}${ReplaceAll<rest2, lookup, replacement>}`
+          : sentence
+        : string
+      : string;
   }
 }
 
diff --git a/types/tuple.d.ts b/types/tuple.d.ts
index c70b660..ff659ce 100644
--- a/types/tuple.d.ts
+++ b/types/tuple.d.ts
@@ -3,282 +3,281 @@
 /// <reference path='./string.d.ts' />
 
 declare global {
-  export namespace StringLiteralList {
+  export namespace StringLiteralList {}
+  /**
+   * @name tuple
+   * @description A tuple is a an immutable list of elements that infer the position and the length of its elements.
+   * This is useful to create an array that is used as an argument for a function that requires an ordered list of parameters.
+   */
+  export namespace StringLiteralList.tuple {
+    export type GetTuplePositiveIndex<
+      T extends readonly any[],
+      I extends number,
+    > =
+      generic.IsNegative<I> extends false
+        ? I
+        : generic.Subtract<T['length'], generic.Abs<I>>;
+
+    export type IsStringLiteralArray<Arr extends string[] | readonly string[]> =
+      string.IsStringLiteral<Arr[number]> extends true ? true : false;
     /**
-     * @name tuple
-     * @description A tuple is a an immutable list of elements that infer the position and the length of its elements.
-     * This is useful to create an array that is used as an argument for a function that requires an ordered list of parameters.
+     * Takes a union of strings and returns a tuple of them.
+     * @deprecated this doesn't infer the length and the position of the tuple. It will also drop duplicates.
      */
-    export namespace tuple {
-      export type GetTuplePositiveIndex<
-        T extends readonly any[],
-        I extends number,
-      > =
-        generic.IsNegative<I> extends false
-          ? I
-          : generic.Subtract<T['length'], generic.Abs<I>>;
-
-      type IsStringLiteralArray<Arr extends string[] | readonly string[]> =
-        string.IsStringLiteral<Arr[number]> extends true ? true : false;
-      /**
-       * Takes a union of strings and returns a tuple of them.
-       * @deprecated this doesn't infer the length and the position of the tuple. It will also drop duplicates.
-       */
-      export type UnionToTuple<T extends string> =
-        generic.UnionToIntersection<
-          T extends never ? never : T extends string ? (t: T) => T : never
-        > extends (_: never) => infer W
-          ? W extends string
-            ? readonly [...UnionToTuple<Exclude<T, W>>, W]
-            : never
-          : readonly [];
+    export type UnionToTuple<T extends string> =
+      generic.UnionToIntersection<
+        T extends never ? never : T extends string ? (t: T) => T : never
+      > extends (_: never) => infer W
+        ? W extends string
+          ? readonly [...UnionToTuple<Exclude<T, W>>, W]
+          : never
+        : readonly [];
 
-      export type TupleSplit<
-        T,
-        N extends number,
-        O extends readonly any[] = readonly [],
-      > = O['length'] extends N
-        ? [O, T]
-        : T extends readonly [infer F, ...infer R]
-          ? TupleSplit<readonly [...R], N, readonly [...O, F]>
-          : [O, T];
+    export type TupleSplit<
+      T,
+      N extends number,
+      O extends readonly any[] = readonly [],
+    > = O['length'] extends N
+      ? [O, T]
+      : T extends readonly [infer F, ...infer R]
+        ? TupleSplit<readonly [...R], N, readonly [...O, F]>
+        : [O, T];
 
-      type TupleExplode<T, Exploded extends any[] = []> = T extends readonly [
-        infer Head,
-        ...infer Rest,
-      ]
-        ? Head extends readonly []
-          ? Exploded
-          : Rest extends readonly []
-            ? [...Exploded, readonly [Head]]
-            : TupleExplode<Rest, [...Exploded, readonly [Head]]>
-        : Exploded;
+    export type TupleExplode<
+      T,
+      Exploded extends any[] = [],
+    > = T extends readonly [infer Head, ...infer Rest]
+      ? Head extends readonly []
+        ? Exploded
+        : Rest extends readonly []
+          ? [...Exploded, readonly [Head]]
+          : TupleExplode<Rest, [...Exploded, readonly [Head]]>
+      : Exploded;
 
-      type TupleImplode<
-        T,
-        Imploded extends readonly any[] = readonly [],
-      > = T extends readonly [infer Head, ...infer Rest]
-        ? Head extends readonly []
-          ? Imploded
-          : Head extends readonly [...infer Head]
-            ? Rest extends readonly []
-              ? readonly [...Imploded, ...Head]
-              : TupleImplode<Rest, [...Imploded, ...Head]>
-            : Imploded
-        : Imploded;
+    export type TupleImplode<
+      T,
+      Imploded extends readonly any[] = readonly [],
+    > = T extends readonly [infer Head, ...infer Rest]
+      ? Head extends readonly []
+        ? Imploded
+        : Head extends readonly [...infer Head]
+          ? Rest extends readonly []
+            ? readonly [...Imploded, ...Head]
+            : TupleImplode<Rest, [...Imploded, ...Head]>
+          : Imploded
+      : Imploded;
 
-      type TakeFirst<T extends readonly any[], N extends number> = TupleSplit<
-        T,
-        N
-      >[0];
+    export type TakeFirst<
+      T extends readonly any[],
+      N extends number,
+    > = TupleSplit<T, N>[0];
 
-      type SkipFirst<T extends readonly any[], N extends number> = TupleSplit<
-        T,
-        N
-      >[1];
+    export type SkipFirst<
+      T extends readonly any[],
+      N extends number,
+    > = TupleSplit<T, N>[1];
 
-      type TupleSlice<
-        T extends readonly any[],
-        S extends number,
-        E extends number,
-      > = SkipFirst<TakeFirst<T, E>, S>;
+    export type TupleSlice<
+      T extends readonly any[],
+      S extends number,
+      E extends number,
+    > = SkipFirst<TakeFirst<T, E>, S>;
 
-      export type TuplePrefixed<
-        T extends readonly string[],
-        P extends string,
-        Transformed extends readonly string[],
-      > = T extends readonly [infer H, ...infer R]
-        ? H extends string
-          ? R extends readonly string[]
-            ? TuplePrefixed<R, P, readonly [...Transformed, `${P}${H}`]>
-            : readonly [...Transformed, `${P}${H}`]
-          : Transformed
-        : Transformed;
+    export type TuplePrefixed<
+      T extends readonly string[],
+      P extends string,
+      Transformed extends readonly string[],
+    > = T extends readonly [infer H, ...infer R]
+      ? H extends string
+        ? R extends readonly string[]
+          ? TuplePrefixed<R, P, readonly [...Transformed, `${P}${H}`]>
+          : readonly [...Transformed, `${P}${H}`]
+        : Transformed
+      : Transformed;
 
-      export type TupleSuffixed<
-        T extends readonly string[],
-        S extends string,
-        Transformed extends readonly string[],
-      > = T extends readonly [infer H, ...infer R]
-        ? H extends string
-          ? R extends readonly string[]
-            ? TupleSuffixed<R, S, readonly [...Transformed, `${H}${S}`]>
-            : readonly [...Transformed, `${H}${S}`]
-          : Transformed
-        : Transformed;
+    export type TupleSuffixed<
+      T extends readonly string[],
+      S extends string,
+      Transformed extends readonly string[],
+    > = T extends readonly [infer H, ...infer R]
+      ? H extends string
+        ? R extends readonly string[]
+          ? TupleSuffixed<R, S, readonly [...Transformed, `${H}${S}`]>
+          : readonly [...Transformed, `${H}${S}`]
+        : Transformed
+      : Transformed;
 
-      export type TupleWithReplace<
-        T extends readonly string[],
-        Lookup extends string | RegExp,
-        Replacement extends string,
-        Transformed extends readonly string[],
-        All extends boolean = false,
-      > = T extends readonly [infer H, ...infer R]
-        ? H extends string
-          ? R extends readonly string[]
-            ? TupleWithReplace<
-                R,
-                Lookup,
-                Replacement,
-                readonly [
-                  ...Transformed,
-                  [All] extends [false]
-                    ? string.Replace<H, Lookup, Replacement>
-                    : string.ReplaceAll<H, Lookup, Replacement>,
-                ],
-                All
-              >
-            : readonly [
+    export type TupleWithReplace<
+      T extends readonly string[],
+      Lookup extends string | RegExp,
+      Replacement extends string,
+      Transformed extends readonly string[],
+      All extends boolean = false,
+    > = T extends readonly [infer H, ...infer R]
+      ? H extends string
+        ? R extends readonly string[]
+          ? TupleWithReplace<
+              R,
+              Lookup,
+              Replacement,
+              readonly [
                 ...Transformed,
                 [All] extends [false]
                   ? string.Replace<H, Lookup, Replacement>
                   : string.ReplaceAll<H, Lookup, Replacement>,
-              ]
-          : Transformed
-        : Transformed;
+              ],
+              All
+            >
+          : readonly [
+              ...Transformed,
+              [All] extends [false]
+                ? string.Replace<H, Lookup, Replacement>
+                : string.ReplaceAll<H, Lookup, Replacement>,
+            ]
+        : Transformed
+      : Transformed;
 
-      export type TupleWithCaseTransform<
-        T extends readonly string[],
-        Transform extends
-          | 'uppercase'
-          | 'lowercase'
-          | 'capitalize'
-          | 'unCapitalize',
-        Transformed extends readonly string[],
-      > = T extends readonly [infer H, ...infer R]
-        ? H extends string
-          ? R extends readonly string[]
-            ? TupleWithCaseTransform<
-                R,
-                Transform,
-                readonly [...Transformed, string.CaseTransform<H, Transform>]
-              >
-            : readonly [...Transformed, string.CaseTransform<H, Transform>]
-          : Transformed
-        : Transformed;
+    export type TupleWithCaseTransform<
+      T extends readonly string[],
+      Transform extends
+        | 'uppercase'
+        | 'lowercase'
+        | 'capitalize'
+        | 'unCapitalize',
+      Transformed extends readonly string[],
+    > = T extends readonly [infer H, ...infer R]
+      ? H extends string
+        ? R extends readonly string[]
+          ? TupleWithCaseTransform<
+              R,
+              Transform,
+              readonly [...Transformed, string.CaseTransform<H, Transform>]
+            >
+          : readonly [...Transformed, string.CaseTransform<H, Transform>]
+        : Transformed
+      : Transformed;
 
-      export type TupleWithTrim<
-        T extends readonly string[],
-        Transformed extends readonly string[],
-      > = T extends readonly [infer H, ...infer R]
-        ? H extends string
-          ? R extends readonly string[]
-            ? TupleWithTrim<R, readonly [...Transformed, string.Trim<H>]>
-            : readonly [...Transformed, string.Trim<H>]
-          : Transformed
-        : Transformed;
+    export type TupleWithTrim<
+      T extends readonly string[],
+      Transformed extends readonly string[],
+    > = T extends readonly [infer H, ...infer R]
+      ? H extends string
+        ? R extends readonly string[]
+          ? TupleWithTrim<R, readonly [...Transformed, string.Trim<H>]>
+          : readonly [...Transformed, string.Trim<H>]
+        : Transformed
+      : Transformed;
 
-      export type TupleWithExclude<
-        T extends readonly string[],
-        E extends string,
-        Transformed extends readonly string[],
-      > = T extends readonly [infer H, ...infer R]
-        ? H extends string
-          ? R extends readonly string[]
-            ? TupleWithExclude<
-                R,
-                E,
-                [H] extends [E] ? Transformed : readonly [...Transformed, H]
-              >
-            : [H] extends [E]
-              ? Transformed
-              : readonly [...Transformed, H]
-          : Transformed
-        : Transformed;
+    export type TupleWithExclude<
+      T extends readonly string[],
+      E extends string,
+      Transformed extends readonly string[],
+    > = T extends readonly [infer H, ...infer R]
+      ? H extends string
+        ? R extends readonly string[]
+          ? TupleWithExclude<
+              R,
+              E,
+              [H] extends [E] ? Transformed : readonly [...Transformed, H]
+            >
+          : [H] extends [E]
+            ? Transformed
+            : readonly [...Transformed, H]
+        : Transformed
+      : Transformed;
 
-      export type TupleReversed<
-        T extends readonly string[],
-        Reversed extends readonly string[],
-      > = T extends readonly [infer H, ...infer R]
-        ? H extends string
-          ? R extends readonly string[]
-            ? Reversed extends readonly string[]
-              ? TupleReversed<readonly [...R], readonly [H, ...Reversed]>
-              : readonly [H, ...R]
-            : readonly [H]
-          : Reversed
-        : Reversed;
+    export type TupleReversed<
+      T extends readonly string[],
+      Reversed extends readonly string[],
+    > = T extends readonly [infer H, ...infer R]
+      ? H extends string
+        ? R extends readonly string[]
+          ? Reversed extends readonly string[]
+            ? TupleReversed<readonly [...R], readonly [H, ...Reversed]>
+            : readonly [H, ...R]
+          : readonly [H]
+        : Reversed
+      : Reversed;
 
-      type JoinInner<
-        T extends readonly string[],
-        delimiter extends string = '',
-      > = T extends readonly [
-        infer first extends string,
-        ...infer rest extends readonly string[],
-      ]
-        ? rest extends []
-          ? first
-          : `${first}${delimiter}${JoinInner<rest, delimiter>}`
-        : '';
+    export type JoinInner<
+      T extends readonly string[],
+      delimiter extends string = '',
+    > = T extends readonly [
+      infer first extends string,
+      ...infer rest extends readonly string[],
+    ]
+      ? rest extends []
+        ? first
+        : `${first}${delimiter}${JoinInner<rest, delimiter>}`
+      : '';
 
-      export type Join<
-        T extends readonly string[],
-        delimiter extends string = '',
-      > = delimiter extends string
-        ? T extends readonly string[]
-          ? TupleSplit<T, 30> extends [
-              infer L extends readonly string[],
-              infer R extends readonly string[],
-            ]
-            ? JoinInner<L, delimiter> extends infer C extends string
-              ? `${R['length']}` extends `0`
-                ? C
-                : R extends readonly string[]
-                  ? string.Length<`${R['length']}`> extends 1 | 2
-                    ? JoinInner<R, delimiter> extends infer D extends string
-                      ? `${C}${D}`
-                      : Join<readonly [C, ...R], delimiter>
-                    : ''
+    export type Join<
+      T extends readonly string[],
+      delimiter extends string = '',
+    > = delimiter extends string
+      ? T extends readonly string[]
+        ? TupleSplit<T, 30> extends [
+            infer L extends readonly string[],
+            infer R extends readonly string[],
+          ]
+          ? JoinInner<L, delimiter> extends infer C extends string
+            ? `${R['length']}` extends `0`
+              ? C
+              : R extends readonly string[]
+                ? string.Length<`${R['length']}`> extends 1 | 2
+                  ? JoinInner<R, delimiter> extends infer D extends string
+                    ? `${C}${D}`
+                    : Join<readonly [C, ...R], delimiter>
                   : ''
-              : ''
+                : ''
             : ''
-          : never
-        : never;
+          : ''
+        : never
+      : never;
 
-      export type TupleJoin<
-        T extends readonly string[],
-        Joined extends readonly string[],
-      > = T extends readonly [infer A, ...infer Rest]
-        ? A extends { infered: { Tuple: readonly string[] } }
-          ? Rest extends readonly []
-            ? readonly [...Joined, ...A['infered']['Tuple']]
-            : Rest extends readonly { infered: { Tuple: readonly string[] } }[]
-              ? ILiteralsTupleJoin<Rest, [...Joined, ...A['infered']['Tuple']]>
-              : Joined
-          : []
-        : [];
+    export type TupleJoin<
+      T extends readonly string[],
+      Joined extends readonly string[],
+    > = T extends readonly [infer A, ...infer Rest]
+      ? A extends { infered: { Tuple: readonly string[] } }
+        ? Rest extends readonly []
+          ? readonly [...Joined, ...A['infered']['Tuple']]
+          : Rest extends readonly { infered: { Tuple: readonly string[] } }[]
+            ? ILiteralsTupleJoin<Rest, [...Joined, ...A['infered']['Tuple']]>
+            : Joined
+        : []
+      : [];
 
-      export type ILiteralsTupleJoin<
-        T extends readonly Partial<{
-          infered: Partial<{ Tuple: readonly unknown[] }>;
-        }>[],
-        Joined extends readonly string[],
-      > = T extends readonly [infer A, ...infer Rest]
-        ? A extends Partial<{ infered: Partial<{ Tuple: readonly string[] }> }>
-          ? Rest extends []
-            ? A['infered']['Tuple'] extends infer L extends readonly string[]
-              ? readonly [...Joined, ...L]
-              : never
-            : Rest extends readonly Partial<{
-                  infered: Partial<{ Tuple: readonly unknown[] }>;
-                }>[]
-              ? A['infered']['Tuple'] extends infer L extends readonly string[]
-                ? ILiteralsTupleJoin<Rest, [...Joined, ...L]>
-                : never
-              : Joined
-          : A extends Partial<{
-                infered: Partial<{ Tuple: readonly string[] }>;
-              }>
+    export type ILiteralsTupleJoin<
+      T extends readonly Partial<{
+        infered: Partial<{ Tuple: readonly unknown[] }>;
+      }>[],
+      Joined extends readonly string[],
+    > = T extends readonly [infer A, ...infer Rest]
+      ? A extends Partial<{ infered: Partial<{ Tuple: readonly string[] }> }>
+        ? Rest extends []
+          ? A['infered']['Tuple'] extends infer L extends readonly string[]
+            ? readonly [...Joined, ...L]
+            : never
+          : Rest extends readonly Partial<{
+                infered: Partial<{ Tuple: readonly unknown[] }>;
+              }>[]
             ? A['infered']['Tuple'] extends infer L extends readonly string[]
-              ? [...Joined, ...A['infered']['Tuple']]
+              ? ILiteralsTupleJoin<Rest, [...Joined, ...L]>
               : never
-            : Rest extends readonly Partial<{
-                  infered: Partial<{ Tuple: readonly unknown[] }>;
-                }>[]
-              ? ILiteralsTupleJoin<Rest, Joined>
-              : Joined
-        : Joined;
-    }
+            : Joined
+        : A extends Partial<{
+              infered: Partial<{ Tuple: readonly string[] }>;
+            }>
+          ? A['infered']['Tuple'] extends infer L extends readonly string[]
+            ? [...Joined, ...A['infered']['Tuple']]
+            : never
+          : Rest extends readonly Partial<{
+                infered: Partial<{ Tuple: readonly unknown[] }>;
+              }>[]
+            ? ILiteralsTupleJoin<Rest, Joined>
+            : Joined
+      : Joined;
   }
 }