inferred-types 0.51.1 → 0.51.2

package/src/types/string-literals/Time.ts

@@ -1,333 +0,0 @@
-import {  Default, EmptyObject, IndexOf, NonZeroNumericChar, NumericChar, NumericCharZeroToFive, PlusMinus, TypeRequired, TypeStrength } from "inferred-types/dist/types/index";
-
-type CivilianTwoDigitHour = "10" | "11" | "12";
-export type TimeResolution = "HH:MM" | "HH:MM:SS" | "HH:MM:SS.ms";
-export type TimeNomenclature = "military" | "civilian";
-export type AmPmCase = "lower" | "upper" | "bare";
-
-
-/**
- * **CivilianHours**`<[TFixedLengthHours]>`
- *
- * The _hours_ used in the civilian clock (aka, 1-12)
- */
-export type CivilianHours<
-  TFixedLengthHours extends boolean = false
-> = TFixedLengthHours extends true
-? `0${Exclude<NumericChar, "0">}` | CivilianTwoDigitHour
-: NonZeroNumericChar | CivilianTwoDigitHour | `0${NonZeroNumericChar}`;
-
-/**
- * **CivilianTimeOptions**
- *
- * The optional configuration for a civilian "time" type.
- */
-export type CivilianTimeOptions = {
-  strength?: TypeStrength;
-  fixedLengthHours?: boolean;
-  timezone?: TypeRequired;
-  amPmCase?: AmPmCase;
-}
-
-/**
- * **MilitaryTimeOptions**
- *
- * The optional configuration for a military "time" type.
- */
-export type MilitaryTimeOptions = Omit<CivilianTimeOptions, "amPmCase">;
-
-
-/**
- * The user's options merged with default values
- */
-type Opt<T extends MilitaryTimeOptions | CivilianTimeOptions> = {
-  strength: Default<IndexOf<T, "strength", undefined>, "strong">;
-  fixedLengthHours: Default<IndexOf<T, "fixedLengthHours", undefined>, false>;
-  timezone: Default<IndexOf<T, "timezone", undefined>, "exclude">;
-  amPmCase: Default<IndexOf<T, "amPmCase", undefined>, "lower">;
-}
-
-
-/**
- * **Minutes**`<[TStr]>`
- *
- * Provides a typing for the minutes component of Time (aka, 00 to 59).
- */
-export type Minutes<TStr extends TypeStrength = "strong"> = TStr extends "strong"
-  ? `${NumericCharZeroToFive}${NumericChar}`
-  : `${NumericCharZeroToFive}${number}`;
-
-/**
- * **Seconds**`<[TStr]>`
- *
- * Provides a typing for the seconds component of Time (aka, 00 to 59).
- */
-export type Seconds<TStr extends TypeStrength = "strong"> = TStr extends "strong"
-  ? `${NumericCharZeroToFive}${NumericChar}`
-  : `${NumericCharZeroToFive}${number}`;
-
-/**
- * **Milliseconds**`<[TStr]>`
- *
- * Provides a typing for the milliseconds component of Time (aka, 000 to 999).
- */
-export type Milliseconds<TStr extends TypeStrength = "strong"> = TStr extends "strong"
-  ? `${NumericChar}${NumericChar}${NumericChar}`
-  : number;
-
-
-export type AmPm<
-  TCase extends AmPmCase = "lower"
-> = TCase extends "lower"
-? "am" | "pm"
-: TCase extends "upper"
-  ? "AM" | "PM"
-  : "";
-
-
-export type TzHourOffset = `0${NumericChar}` | "10" | "11";
-
-/**
- * **TZ**`<TStrength>`
- *
- * Creates a type for timezones.
- *
- * - by default chooses a "strong" type but "simple" or "exclude"
- * are other options for the `TStrength` generic.
- */
-export type TZ<
-  TRequire extends "required" | "optional" | "exclude" = "required"
-> = TRequire extends "exclude"
-? ""
-: TRequire extends "optional"
-    ? `${PlusMinus}:${number}:${number}` | ""
-    : `${PlusMinus}:${number}:${number}`;
-
-/**
- * **TimeLike**
- *
- * A representation of _time_ values which aims to keep the typing
- * open to as many formats as possible but at the cost being somewhat
- * less detailed in it's typing.
- *
- * **Related:** `Time`, `MilitaryTime`, `CivilianTime`
- */
-export type TimeLike = `${number}:${number}${`:${number}` | ""}${" " | ""}${"am" | "pm" | "AM" | "PM" | ""}${`${PlusMinus}:${number}:${number}` | ""}`
-
-
-/**
- * **MilitaryHours**
- *
- * The _hours_ component of Time when using military nomenclature.
- */
-export type MilitaryHours<
-  TFixedLengthHours extends boolean = true
-> = TFixedLengthHours extends true
-? `${"0" | "1"}${NumericChar}` | "20" | "21" | "22" | "23"
-: `${""|"0" | "1"}${NumericChar}` | "20" | "21" | "22" | "23";
-
-
-
-
-/**
- * **HoursMinutes**`<[TOpt]>`
- *
- * Time expressed as just hours and minutes in military time.
- *
- * - by default the timezone is excluded but this can be modified
- * with the optional `TTimezone` generic.
- */
-export type HoursMinutes<
-  TOpt extends MilitaryTimeOptions = Opt<EmptyObject>
-> = Opt<TOpt>["strength"] extends "strong"
-  ? `${MilitaryHours<Opt<TOpt>["fixedLengthHours"]>}:${Minutes}${TZ<Opt<TOpt>["timezone"]>}`
-  : `${number}:${number}${TZ<Opt<TOpt>["timezone"]>}`;
-
-/**
- * **HoursMinutes12**`<[TOpt]>`
- *
- * Time expressed as just hours and minutes using the 12 hour civilian nomenclature
- * and requiring that an `AmPm<TCase>` indicator be included at the end of the time.
- *
- * **Note:** by default the `TCase` generic defaults to _lower_ which means that "am" and "pm"
- * are the expected markers for the 12 hour clock you are in.
- */
-export type HoursMinutes12<
-  TOpt extends CivilianTimeOptions = Opt<EmptyObject>
-> = Opt<TOpt>["strength"] extends "strong"
-? `${CivilianHours<Opt<TOpt>["fixedLengthHours"]>}:${NumericCharZeroToFive}${NumericChar}${AmPm<Opt<TOpt>["amPmCase"]>}${TZ<Opt<TOpt>["timezone"]>}`
-: `${number}:${number}${AmPm<Opt<TOpt>["amPmCase"]>}${TZ< Opt<TOpt>["timezone"]>}`;
-
-/**
- * **HoursMinutesSeconds**`<[TOpt]>`
- *
- * Time expressed in hours, minutes, and seconds in military nomenclature. Timezone is
- * excluded by default but can be enabled with `TTimezone` generic.
- */
-export type HoursMinutesSeconds<
-  TOpt extends MilitaryTimeOptions = Opt<EmptyObject>
-> = Opt<TOpt>["strength"] extends "strong"
-  ? `${HoursMinutes<TOpt>}:${Seconds<"simple">}${TZ<Opt<TOpt>["timezone"]>}`
-  : `${number}:${number}:${number}${TZ<Opt<TOpt>["timezone"]>}`;
-
-
-export type HoursMinutesSecondsMilliseconds<
-  TOpt extends MilitaryTimeOptions = Opt<EmptyObject>
-> = Opt<TOpt>["strength"] extends "strong"
-  ? `${HoursMinutes}:${Seconds<"simple">}.${number}${TZ< Opt<TOpt>["timezone"]>}`
-  : `${number}:${number}:${number}.${number}${TZ<Opt<TOpt>["timezone"]>}`;
-
-/**
- * **HoursMinutesSeconds12**`<[TTimezone]>`
- *
- * Time expressed in hours, minutes, and seconds in civilian nomenclature. Timezone is
- * excluded by default but can be enabled with `TTimezone` generic.
- */
-export type HoursMinutesSeconds12<
-  TOpt extends CivilianTimeOptions = Opt<EmptyObject>
-> = Opt<TOpt>["strength"] extends "strong"
-? `${HoursMinutes}:${Seconds<"simple">}${AmPm<Opt<TOpt>["amPmCase"]>}${TZ<Opt<TOpt>["timezone"]>}`
-: `${number}:${number}:${number}${AmPm<Opt<TOpt>["amPmCase"]>}${TZ<Opt<TOpt>["timezone"]>}`;
-
-export type HoursMinutesSecondsMilliseconds12<
-  TOpt extends CivilianTimeOptions = Opt<EmptyObject>
-> = Opt<TOpt>["strength"] extends "strong"
-? `${HoursMinutes}:${Seconds<"simple">}.${number}${AmPm<Opt<TOpt>["amPmCase"]>}${TZ< Opt<TOpt>["timezone"]>}`
-: `${number}:${number}:${number}.${number}${AmPm<Opt<TOpt>["amPmCase"]>}${TZ<Opt<TOpt>["timezone"]>}`;
-
-/**
- * **TimeInMinutes**`<TNomenclature,[TOpts]>`
- *
- * Time expressed with a time resolution of `HH:MM` (e.g., `12:43pm` or `23:15`).
- *
- * The nomenclatures of _military_ versus _civilian_ are both allowed
- * by default but can be isolated with the use the `TNomenclature` generic.
- */
-export type TimeInMinutes<
-  TNomenclature extends TimeNomenclature = "military",
-  TOpt extends CivilianTimeOptions = Opt<EmptyObject>
-> = TNomenclature extends "military"
-  ? HoursMinutes<TOpt>
-  : TNomenclature extends "civilian"
-    ? HoursMinutes12<TOpt>
-    : never;
-
-/**
- * **TimeInSeconds**`<[TNomenclature],[TOpts]>`
- *
- * Time expressed in `HH:MM:SS` resolution.
- *
- * By default either military or civilian nomenclature is allowed but
- * this can be isolated by using the `TNomenclature` generic.
- *
- * ```ts
- * const ex1: TimeInSeconds = "9:45:15pm";
- * const ex2: TimeInSeconds = "21:45:15"
- * ```
- */
-export type TimeInSeconds<
-  TNomenclature extends TimeNomenclature = "military",
-  TOpt extends CivilianTimeOptions = Opt<EmptyObject>
-> = TNomenclature extends "military"
-  ? HoursMinutesSeconds<TOpt>
-  : TNomenclature extends "civilian"
-    ? HoursMinutesSeconds12<TOpt>
-    : never;
-
-export type TimeInMilliseconds<
-  TNomenclature extends TimeNomenclature = "military",
-  TOpt extends CivilianTimeOptions = Opt<EmptyObject>
-> = TNomenclature extends "military"
-    ? HoursMinutesSecondsMilliseconds<TOpt>
-    : TNomenclature extends "civilian"
-      ? HoursMinutesSecondsMilliseconds12<TOpt>
-      : never;
-
-
-/**
- * **MilitaryTime**
- *
- * Provides a type for military time.
- *
- * - by default the resolution is "all" but can be modified with `TResolution`
- * - when _all_ time resolutions are allowed the strength is always set to "simple"
- * - in all other cases, `TStr` will specify the strength of the particular time
- * resolution
- */
-export type MilitaryTime<
-  TResolution extends TimeResolution,
-  TOpt extends MilitaryTimeOptions = Opt<EmptyObject>
-> = TResolution extends "all"
-? TimeInMinutes<
-  "military", {
-      strength: "simple";
-      timezone: Opt<TOpt>["timezone"];
-      amPmCase: Opt<TOpt>["amPmCase"];
-      fixedLengthHours: Opt<TOpt>["fixedLengthHours"];
-    }>
-  | TimeInSeconds<"military", {
-      strength: "simple";
-      timezone: Opt<TOpt>["timezone"];
-      amPmCase: Opt<TOpt>["amPmCase"];
-      fixedLengthHours: Opt<TOpt>["fixedLengthHours"];
-    }>
-  | TimeInMilliseconds<"military",{
-    strength: "simple";
-    timezone: Opt<TOpt>["timezone"];
-    amPmCase: Opt<TOpt>["amPmCase"];
-    fixedLengthHours: Opt<TOpt>["fixedLengthHours"];
-    } >
-: TResolution extends "HH:MM"
-  ? HoursMinutes<TOpt>
-  : TResolution extends "HH:MM:SS"
-    ? HoursMinutesSeconds<TOpt>
-    : TResolution extends "HH:MM:SS.ms"
-      ? HoursMinutesSecondsMilliseconds<TOpt>
-      : never;
-
-/**
- * **CivilianTime**
- *
- * Allows time resolution of HH:MM or HH:MM:SS in civilian time (aka, 12 hour time with AM/PM).
- */
-export type CivilianTime<
-  TResolution extends TimeResolution,
-  TOpt extends CivilianTimeOptions = Opt<EmptyObject>
-> = TResolution extends "HH:MM"
-  ? HoursMinutes12<TOpt>
-  : TResolution extends "HH:MM:SS"
-    ? HoursMinutesSeconds12<TOpt>
-    : TResolution extends "HH:MM:SS.ms"
-      ? HoursMinutesSecondsMilliseconds12<TOpt>
-      : never;
-
-
-/**
- * **Time**`<TResolution,[TNomenclature], [TOpts]>`
- *
- * A _simplified_ type for Time which accepts military and civilian
- * nomenclature as well as `HH:MM` and `HH:MM:SS` resolutions.
- *
- * You can use the `TNomenclature` and `TResolution` generics to constrain
- * what is allowed (and further simplify the type).
- *
- * **Related:** `MilitaryTime`, `CivilianTime`, `TimeLike`
- */
-export type Time<
-  TResolution extends TimeResolution,
-  TNomenclature extends TimeNomenclature = "military",
-  TOpt extends CivilianTimeOptions = Opt<EmptyObject>
-> = TResolution extends "HH:MM"
-    ? TimeInMinutes<TNomenclature, TOpt>
-
-    : TResolution extends "HH:MM:SS"
-      ? TimeInSeconds<TNomenclature, TOpt>
-
-      : TResolution extends "HH:MM:SS.ms"
-        ? TimeInMilliseconds<TNomenclature, {
-            strength: "simple";
-            timezone: Opt<TOpt>["timezone"];
-            amPmCase: Opt<TOpt>["amPmCase"];
-            fixedLengthHours: Opt<TOpt>["fixedLengthHours"];
-          }>
-        : never;

package/src/types/string-literals/Truncate.ts

@@ -1,59 +0,0 @@
-import {
-  IsEqual,
-  IsGreaterThan,
-  If,
-  StrLen,
-  Concat,
-  Chars,
-  TakeFirst
-} from "inferred-types/dist/types/index";
-
-type Ellipsis<T extends boolean | string> = T extends string
-  ? T
-  : T extends true ? "..." : "";
-
-type _Truncate<
-  TStr extends readonly string[],
-  TMaxLen extends number,
-  TEllipsis extends string
-> = TakeFirst<TStr, TMaxLen> extends readonly string[]
-? Concat<[...TakeFirst<TStr, TMaxLen>, TEllipsis]>
-: never
-
-/**
- * **Truncate**`<TStr,TMaxLen,[TEllipsis]>`
- *
- * Type utility which ensures that strings and/or tuples beyond the length
- * of `TMaxLen` are truncated at this length.
- *
- * - if the optional `TEllipsis` is set to **true** three
- * period characters will be added after the truncation
- * in cases where text was actually truncated.
- * - if you want to create your own terminal ellipsis representation you can
- * add a string literal value to the `TEllipsis` property
- */
-export type Truncate<
-  TContent extends string,
-  TMaxLen extends number,
-  TEllipsis extends boolean | string = false
-> = TContent extends string
-? If<
-    IsEqual<TMaxLen, number>,
-    // non-literal value for max
-    never,
-    If<
-      IsGreaterThan<StrLen<TContent>, TMaxLen>,
-      // truncation required
-      _Truncate<
-        Chars<TContent>,
-        TMaxLen,
-        Ellipsis<TEllipsis>
-      >,
-      // no truncation required
-      TContent
-    >
-  >
-
-  : never;
-
-

package/src/types/string-literals/UnderlyingType.ts

@@ -1,29 +0,0 @@
-import { AsBoolean, AsNumber, BooleanLike, NumberLike } from "inferred-types/dist/types/index";
-
-type Process<
-T
-> = T extends NumberLike
-? AsNumber<T>
-: T extends BooleanLike
-? AsBoolean<T>
-: T;
-
-
-/**
- * **UnderlyingType**`<T>`
- *
- * If `T` is a string literal which is `NumberLike` or `BooleanLike`
- * then it converts it to the appropriate numeric or boolean type.
- *
- * If `T` is a tuple then it will apply this logic to all elements
- * in the tuple.
- *
- * In all other cases it simply proxies the type of `T` through.
- */
-export type UnderlyingType<
-  T
-> = T extends readonly unknown[]
-? {
-  [K in keyof T]: Process<T[K]>
-}
-: Process<T>;

package/src/types/string-literals/casing/AllCaps.ts

@@ -1,24 +0,0 @@
-import {  Chars,  If, IsStringLiteral, Concat} from "inferred-types/dist/types/index";
-
-
-type Process<
-  TChars extends readonly string[]
-> = {
-  [K in keyof TChars]: Capitalize<TChars[K]>
-};
-
-/**
- * **AllCaps**`<T>`
- *
- * Type utility which converts all alphabetic characters to their
- * UPPERCASE variant.
- */
-export type AllCaps<T extends string> = If<
-  IsStringLiteral<T>,
-  Chars<T> extends readonly string[]
-    ? Process<Chars<T>> extends readonly string[]
-      ? Concat<Process<Chars<T>>>
-      : never
-    : Chars<T>,
-  string
->;

package/src/types/string-literals/casing/CamelCase.ts

@@ -1,32 +0,0 @@
-import {
-  IsTrue,
-  If,
-  LeftWhitespace,
-  RightWhitespace,
-  PascalCase ,
-  Concat
-} from "inferred-types/dist/types/index";
-
-/**
- * **CamelCase**`<TString,TPreserveWhitespace>`
- *
- * Converts a string to `CamelCase` format while optionally preserving
- * surrounding whitespace.
- */
-export type CamelCase<
-  TString extends string,
-  TPreserveWhitespace extends boolean = false
-> = If<
-  IsTrue<TPreserveWhitespace>,
-  string extends TString
-    ? string
-    : Concat<[
-      LeftWhitespace<TString>,
-      Uncapitalize<PascalCase<TString>>,
-      RightWhitespace<TString>
-    ]>
-  ,
-  string extends TString
-    ? string
-    : Uncapitalize<PascalCase<TString>>
->;

package/src/types/string-literals/casing/CapFirstAlpha.ts

@@ -1,22 +0,0 @@
-import { Replace , NonAlphaChar } from "inferred-types/dist/types/index";
-
-/**
- * Strips the non-alpha characters that lead a string
- */
-export type StripLeftNonAlpha<S extends string> = S extends `${infer First}${infer Rest}`
-  ? First extends NonAlphaChar
-    ? StripLeftNonAlpha<Rest>
-    : S
-  : never;
-
-/**
- * identifies the leading characters which are _not_ alphabetical
- */
-export type LeadingNonAlpha<S extends string> = Replace<S, StripLeftNonAlpha<S>, "">;
-
-/**
- * Capitalize the first alphabetical character in the string
- */
-export type CapFirstAlpha<T extends string> = LeadingNonAlpha<T> extends string
-  ? `${LeadingNonAlpha<T>}${Capitalize<Replace<T, LeadingNonAlpha<T>, "">>}`
-  : Capitalize<T>;

package/src/types/string-literals/casing/CapitalizeWords.ts

@@ -1,8 +0,0 @@
-/**
- * Capitalize all words in a string
- */
-export type CapitalizeWords<S extends string> =
-  S extends `${infer L} ${infer R}` ? `${CapitalizeWords<L>} ${CapitalizeWords<R>}` :
-  S extends `${infer L},${infer R}` ? `${CapitalizeWords<L>},${CapitalizeWords<R>}` :
-  S extends `${infer L}.${infer R}` ? `${CapitalizeWords<L>}.${CapitalizeWords<R>}` :
-  Capitalize<S>;

package/src/types/string-literals/casing/DashToSnake.ts

@@ -1,3 +0,0 @@
-export type DashToSnake<T extends string> = T extends `${infer HEAD}-${infer TAIL}`
-  ? DashToSnake<`${HEAD}_${TAIL}`>
-  : T;

package/src/types/string-literals/casing/DashUppercase.ts

@@ -1,23 +0,0 @@
-import type { HasUppercase } from "inferred-types/dist/types/index";
-
-type _DU<T extends string> = T extends Lowercase<T> ? T : `-${Lowercase<T>}`;
-
-/**
- * Converts uppercase characters to a dash and then the lowercase equivalent
- *
- * ```ts
- * // "one-two-three"
- * type T = DashUppercase<"oneTwoThree">;
- * ```
- *
- * _Intended to be used as a lower level utility; prefer `Dasherize<T>` for more full-fledged
- * dash solution_.
- */
-export type DashUppercase<T extends string> =
-HasUppercase<T> extends false
-  ? T
-  : T extends `${infer C0}${infer C1}${infer R}`
-    ? `${_DU<C0>}${_DU<C1>}${DashUppercase<R>}`
-    : T extends `${infer C0}${infer R}`
-      ? `${_DU<C0>}${DashUppercase<R>}`
-      : "";

package/src/types/string-literals/casing/KebabCase.ts

@@ -1,48 +0,0 @@
-import {
-  LeftWhitespace,
-  Replace,
-  RightWhitespace,
-  Trim ,
-  Concat,
-  DashUppercase,
-  LowerAllCaps
-} from "inferred-types/dist/types/index"
-
-
-/**
- * **KebabCase**`<TString,TPreserve>`
- *
- * Converts a string literal into a `kebab-case` format while optionally
- * allowing surrounding whitespace.
- *
- * ```ts
- * // "foo-bar"
- * type Dash = Dasherize<"foo_bar">;
- * type Dash = Dasherize<"fooBar">;
- * type Dash = Dasherize<"FooBar">;
- * // "\n  foo-bar \t"
- * type Dash = Dasherize<"\n  foo bar \t">;
- * ```
- */
-export type KebabCase<
-  TString extends string,
-  TPreserve extends boolean = false
-> = TPreserve extends true
-  ? // preserve
-    Concat<[
-      LeftWhitespace<TString>,
-      KebabCase<TString, false>,
-      RightWhitespace<TString>
-    ]>
-
-  : // remove whitespace
-    string extends TString
-      ? string
-      : DashUppercase<Trim<LowerAllCaps<TString>>> extends `${infer Begin}${"_" | " "}${infer Rest}`
-        ? KebabCase<`${Lowercase<Begin>}-${Rest}`>
-        : Replace<
-            Lowercase<
-              DashUppercase<Uncapitalize<Trim<LowerAllCaps<TString>>>>
-            >,
-            "--", "-"
-          >;

package/src/types/string-literals/casing/LowerAllCaps.ts

@@ -1,17 +0,0 @@
-import { IsAllCaps } from "inferred-types/dist/types/index";
-
-
-/**
- * **LowerAllCaps**`<T>
- *
- * Type utility which will convert an "all caps" string to a string where all characters are lowercase; in
- * all other cases it will do nothing and simply return `T` as `T`.
- *
- * **Related:** `RaiseAllLowercase`
- **/
-export type LowerAllCaps<
-  T extends string
-> = IsAllCaps<T> extends true
-? Lowercase<T>
-: T;
-

package/src/types/string-literals/casing/NamingConvention.ts

@@ -1,14 +0,0 @@
-
-/**
- * **NamingConvention**`<[T]>`
- * 
- * A type union between all common naming conventions for
- * variables in programming.
- * 
- * **Related:** `NamingModifier`
- */
-export type NamingConvention = 
-| "camelCase"
-| "PascalCase"
-| "kebab-case"
-| "snake_case";

package/src/types/string-literals/casing/PascalCase.ts

@@ -1,28 +0,0 @@
-/* eslint @typescript-eslint/no-unused-vars: "off" */
-
-import { Trim , LowerAllCaps } from "inferred-types/dist/types/index";
-
-type Delimiter = "_" | "-" | " ";
-
-/** convert all delimiters to dashes */
-type DashDelim<T extends string> = T extends `${infer Begin}${" "}${infer Rest}`
-  ? DashDelim<`${Begin}-${Rest}`>
-  : T extends `${infer Begin}${"_"}${infer Rest}`
-  ? DashDelim<`${Begin}-${Rest}`>
-  : T;
-
-/**
- * Converts a string literal type to a **PascalCase** representation.
- * ```ts
- * // "FooBar"
- * type T = PascalCase<"fooBar">;
- * type T = PascalCase<"foo-bar">;
- * type T = PascalCase<"foo_bar">;
- * type T = PascalCase<"\n foo_bar \t">;
- * ```
- */
-export type PascalCase<S extends string> = string extends S
-  ? string
-  : Trim<DashDelim<LowerAllCaps<S>>> extends `${infer Begin}${Delimiter}${infer Rest}`
-  ? PascalCase<`${Capitalize<Begin>}${Capitalize<Rest>}`>
-  : Capitalize<Trim<LowerAllCaps<S>>>;

package/src/types/string-literals/casing/RaiseAllLowercase.ts

@@ -1,12 +0,0 @@
-import { IsAllLowercase } from "inferred-types/dist/types/index";
-
-/**
- * **RaiseAllLowercase**`<T>`
- *
- * Type utility which will convert an "all lowercase" string to a string where all characters are uppercase; in
- * all other cases it will do nothing and simply return `T` as `T`.
- *
- * **Related:** `LowerAllCaps`
- **/
-export type RaiseAllLowercase<T extends string> = IsAllLowercase<T> extends true ? Uppercase<T> : T;
-