@elliemae/ds-typescript-helpers 3.46.5 → 3.46.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/ds-typescript-helpers",
-  "version": "3.46.5",
+  "version": "3.46.6",
   "license": "MIT",
   "description": "ICE MT - Dimsum - Typescript helpers",
   "files": [
@@ -34,11 +34,11 @@
   },
   "devDependencies": {
     "@elliemae/pui-cli": "9.0.0-next.50",
-    "@elliemae/ds-monorepo-devops": "3.46.5"
+    "@elliemae/ds-monorepo-devops": "3.46.6"
   },
   "publishConfig": {
     "access": "public",
-    "typeSafety": true
+    "typeSafety": false
   },
   "scripts": {
     "dev": "cross-env NODE_ENV=development node ../../../scripts/build/build.mjs --watch",

package/dist/types/index.d.ts

@@ -1,395 +0,0 @@
-/// <reference types="react" />
-export declare namespace TypescriptHelpersT {
-    /** ***************************************************************************
-     *                            A11y Helpers
-     **************************************************************************** */
-    /**
-     * WCAG recommends to not use tabindex values greater than 0 to ensure that the tab order is predictable.
-     * @example
-     * const tabIndex: WCAGTabIndex = 0; // valid
-     * const tabIndex: WCAGTabIndex = -1; // valid
-     *
-     * const tabIndex: WCAGTabIndex = 1; // invalid
-     * const tabIndex: WCAGTabIndex = "1"; // invalid
-     * const tabIndex: WCAGTabIndex = "0"; // invalid
-     * const tabIndex: WCAGTabIndex = "-1"; // invalid
-     */
-    type WCAGTabIndex = 0 | -1;
-    /** ***************************************************************************
-     *                            Function Helpers
-     **************************************************************************** */
-    /**
-     * Helper for declaring generic functions easly. This is usually painful because of the argument spreading
-     * @example
-     * const myFunction: GenericFunc<number,void> = (a) => { console.log(a) }; // a is a number
-     * const myFunction2: GenericFunc<[number, number], string> = (a,b) => `${a + b}`; // a and b are numbers, the return type is a string
-     */
-    type GenericFunc<T = unknown, R = unknown> = (...args: T extends Array<unknown> ? T : T[]) => R;
-    /**
-     * Helper for declaring a void function easly. This is usually painful because of the argument spreading.
-     * @example
-     * const myFunction: VoidGenericFunc<number> = (a) => { console.log(a) }; // a is a number
-     * const myFunction2: VoidGenericFunc<[number, string]> = (a,b) => { console.log(a,b) }; // a is a number, b is a string
-     */
-    type VoidGenericFunc<T = unknown> = GenericFunc<T, void>;
-    /**
-     * Helper for declaring a function that returns a boolean easly. This is usually painful because of the argument spreading
-     * @example
-     * const myFunction: BooleanGetter<number> = (a) =>  a > 0 // a is a number
-     * const myFunction2: BooleanGetter<[number, string]> = (a,b) => a > 0 && b.length > 0 // a is a number, b is a string
-     */
-    type BooleanGetter<T = unknown> = GenericFunc<T, boolean>;
-    /** ***************************************************************************
-     *                            Debugging Helpers
-     **************************************************************************** */
-    /**
-     * debugging helper to show the expanded typescript contract,
-     * it's only useful to debug, it's NOT MEANT to be used for actual declarations
-     * using this for actual declarations will cause the types to be slow to compile/resolve and would have no benefit.
-     * https://stackoverflow.com/questions/57683303/how-can-i-see-the-full-expanded-contract-of-a-typescript-type
-     * @example
-     * type Decorated = {
-     *   a?: string | null
-     *   b?: T2
-     *   c?: T1
-     *   d: string
-     *   e: number
-     * }
-     * type Injected = {
-     *   inj: object
-     * }
-     * // overriding the types from Decorated
-     * type Text = Decorated &
-     *   Injected & {
-     *     name: string;
-     *     type: "text";
-     *     value: string;
-     *     subobject: Injected;
-     *   };
-     *
-     * type Expanded = DebugExpandT<Text>;
-     */
-    type DebugExpandT<T> = T extends (...args: infer A) => infer R ? (...args: DebugExpandT<A>) => DebugExpandT<R> : T extends infer O ? {
-        [K in keyof O]: O[K];
-    } : never;
-    /**
-     * debugging helper to show the expanded typescript contract,
-     * it's only useful to debug, it's NOT MEANT to be used for actual declarations
-     * using this for actual declarations will cause the types to be slow to compile/resolve and would have no benefit.
-     * https://stackoverflow.com/questions/57683303/how-can-i-see-the-full-expanded-contract-of-a-typescript-type
-     * @example
-     * type Decorated = {
-     *   a?: string | null
-     *   b?: T2
-     *   c?: T1
-     *   d: string
-     *   e: number
-     * }
-     * type Injected = {
-     *   inj: object
-     * }
-     * // overriding the types from Decorated
-     * type Text = Decorated &
-     *   Injected & {
-     *     name: string;
-     *     type: "text";
-     *     value: string;
-     *     subobject: Injected;
-     *   };
-     * interface SomeFunction {
-     *   (...args: Text[]): Injected & { error: boolean };
-     * }
-     *
-     * type ExpandedRecursively = DebugExpandRecursivelyT<Text>;
-     */
-    type DebugExpandRecursivelyT<T> = T extends (...args: infer A) => infer R ? (...args: DebugExpandRecursivelyT<A>) => DebugExpandRecursivelyT<R> : T extends object ? T extends infer O ? {
-        [K in keyof O]: DebugExpandRecursivelyT<O[K]>;
-    } : never : T;
-    /** ***************************************************************************
-     *                            React Helpers
-     **************************************************************************** */
-    /**
-     * An helper useful when you need the type of the second return value of React.useState
-     * @example
-     * const MyComponent = ({ setFoo }:{
-     *   setFoo: StateSetter<string>; // our children expects a react "state setter"
-     * }) => {
-     *   const handleClick = () => {
-     *     setFoo('New value');
-     *   };
-     *   return <button onClick={handleClick}>Set Foo</button>;
-     * };
-     * const ParentComponent: React.FC = () => {
-     *   const [foo, setFoo] = React.useState<string>('Initial value');
-     *   return (
-     *     <div>
-     *       <p>Foo: {foo}</p>
-     *       <MyComponent setFoo={setFoo} />
-     *     </div>
-     *   );
-     * };
-     */
-    type StateSetter<T = unknown> = React.Dispatch<React.SetStateAction<T>>;
-    /**
-     * An helper useful when you need to type an higher order component that has no special requirements on the interface of the component it implements
-     * @example
-     * // a generic component that displays a label and a value for the sake of the example
-     * interface LabelValueDisplayerPropsT {
-     *   foo: string;
-     *   bar: number;
-     * }
-     * const LabelValueDisplayer: React.ComponentType<LabelValueDisplayerPropsT> = ({ foo, bar }) => (
-     *   <div>
-     *     <label>{foo}</label>
-     *     <div>{bar}</div>
-     *   </div>
-     * );
-     *
-     * // we are creating an example HOC that logs the props of the component it wraps before rendering it
-     * const withLogging: TypescriptHelpersT.ReactFunctionalHOC<LabelValueDisplayerPropsT> = (Component) => (props) => {
-     *   console.log('Rendering component with props:', props);
-     *   return <Component {...props} />;
-     * };
-     *
-     * // we can now use the HOC to wrap our component
-     * const ComponentWithGenericLogging = withLogging(LabelValueDisplayer);
-     * const ExampleUsageInComponent = () => {
-     *   return <ComponentWithGenericLogging foo="Test" bar={123} />; // <-- this is correctly typed!
-     * };
-     */
-    type ReactFunctionalHOC<T = Record<string, unknown>> = (Component: React.ComponentType<JSX.IntrinsicAttributes & T>) => React.ComponentType<JSX.IntrinsicAttributes & T>;
-    /**
-     * An helper useful when you need to type an higher order component that has special requirements on the interface of the component it implements
-     * @example
-     * // a generic component that displays a label and a value for the sake of the example
-     * interface LabelValueDisplayerPropsT {
-     *   foo: string;
-     *   bar: number;
-     * }
-     * const LabelValueDisplayer: React.ComponentType<LabelValueDisplayerPropsT> = ({ foo, bar }) => (
-     *   <div>
-     *     <label>{foo}</label>
-     *     <div>{bar}</div>
-     *   </div>
-     * );
-     *
-     * interface LoggerProps { loggableTemplateLabel: string; loggableTemplateValue: string; }
-     *
-     * // the HOC we are creating has special requirements on the props of the component it wraps
-     * //  AND it has some requirements on it's own props
-     * const withLogging: ReactFunctionalHOCWithDifferentInterface<LoggerProps, StartingProps> =
-     *   (Component) => ({ loggableTemplateLabel, loggableTemplateValue }) => {
-     *     const startingLabel = loggableTemplateLabel.replace(/{{label was}}/g, "");
-     *     const startingValue = parseInt(
-     *       loggableTemplateValue.replace(/{{value was}}/g, ""),
-     *       10
-     *     );
-     *     console.log(
-     *       `${loggableTemplateLabel.replace(/{{label was}}/g, "Label was -> ")}`,
-     *       `${loggableTemplateValue.replace(/{{value was}}/g, "Value was -> ")}`
-     *     );
-     *     return <Component startA={startingLabel} startB={startingValue} />;
-     *   };
-     *
-     * const ComponentWithSpecialLogging = withLogging(LabelValueDisplayer); // <-- this is correctly typed!
-     * const ExampleUsageInComponent = () => (
-     *   <ComponentWithSpecialLogging
-     *     loggableTemplateLabel="{{label was}}Starting count:"
-     *     loggableTemplateValue="{{value was}}0"
-     *   />
-     * )
-     */
-    type ReactFunctionalHOCWithDifferentInterface<K = Record<string, unknown>, T = Record<string, unknown>> = (Component: React.ComponentType<JSX.IntrinsicAttributes & T>) => React.ComponentType<K>;
-    /**
-     * An helper for declaring the return type of React.useRef in a way that reflects the reality of how it can be used
-     * @example
-     * const ComponentWithRef = () => {
-     *   // starting value for ref should be null
-     *   const myRef: T.AnyRef<HTMLDivElement> = React.useRef<HTMLDivElement>(null);
-     *   return (<div ref={
-     *     (node => {
-     *       // when used it should reflect what you can actually do with it, mutating it is valid.
-     *       myRef.current = node;
-     *     })
-     *   }>Hello, world!</div>)
-     * };
-     */
-    type AnyRef<T> = React.MutableRefObject<T | null> | ((_ref: T | null) => void);
-    /**
-     * An helper for defining the type of the children prop of a React component
-     * @example
-     * type ReactChildrenComplete = React.PropsWithChildren<object>["children"];
-     * type MyComponentProps = {
-     *   children: ReactChildrenComplete;
-     *   foo: string;
-     * };
-     * const MyComponent = ({ children, foo }: MyComponentProps) => ( <div>{children}{foo}</div> );
-     */
-    type ReactChildrenComplete = React.PropsWithChildren<object>['children'];
-    /** ***************************************************************************
-     *                            Object Helpers
-     **************************************************************************** */
-    /**
-     * Helper to declare an object that has at least one of the keys of the original object as required
-     * https://www.typescriptlang.org/play?#code/C4TwDgpgBAShCOBXAlgJwgQWAGQgQwGdgB5AOwgB4AVAGigGkIQCoIAPYCUgExYGsmAewBmUKlAC8UASBFiAfJICwAKCjqoABWQBjPtToBRNjoA2ibpRlzaDJgXnzVGqADIoAb2cuNAbXpQyKR2zAC6ALQA-ABcsAgo6NwU2noGDI5uWniowMh4psm6+rbGZhaUjMx09I5OahoAvv72oaqqQZyowng60ACyXIgAkpwAtp7eucCmELFEqEEA5gDc3jqCo2CC5KTAMVCkiKMARhCoq-VmRfuHJ2cX6rrbc8ALpCuqDW0qoJBQAMKmIrEVD-DZbHbASRxJBoTA4fBEMiUAaHEYQUZ0ADkVz0WKgAB8oDjwdsuMAsXVVOtSEQoAB3ZDAAAWYM2ZN2sUBwNBpMh0K89XUUxmsQARJwiGKaN51Ot2ZDYgBWABMMqFgRp4qepDFn2+NLpjJZ3L0XKBehBbIh5IFsqgItmUAlECl6pcuL4yoALO6NDrtTS9Sovipqds6WdUIJUAB1JnMgByEATZ3NPOtHKhUkFLkd4slwGl9oDzp1wdD4dpUNIgkMqGjcYTACFBCz05beQrbTn7fnnYXixrPT6-XK+eTYirfSWtWWg-qwypDVCozH4yzWyzY8yuMiABKEWPR95UcBO018K0T3Z2jX9l1u+0jqBKmfDm-AcUEZmCRCmbgoFOA4jlOVAoF3dAhxcUsxXLRdvl+aA4FhdAyFMEBkTSSoWHYTgeH4IRRHEKRrGIxQJHtFJiiMExzEsCgyLEap7Ece13A8KB-ECYIcIiGJ7RcFCEggJJqOwtiNRcdxNGyXJ8goOB1lQJJSnoip7GqeQ6EQHgIGEIJRMklwmj4xDzygdDMPIS9r27W8pGEuErKw1FhjGbFPXxIkSXsikqWXCMazrBt1wTFzyFiCKIFsrsbQciZ7yZUUB1dIsxygF8lQAZnfGC5zghcQwNILWFCptNzbZkotIDDkVizN+V7JLpidR90ufC0vVfXKMvleKvx6jLYPg4ql1UAB6CaxGZZAWA6M5ul6BlkFMUwgOgRACFEh1BAdBY9Es2rrJirqsEa20Oj2-JTEERl3igPBgkEY4ACsIB0KFjWZICqvUdpdkWnpoEvNz0XGXMHWSp15iWB5Mq62JbjA+HS1h94LkrQLqwgwgtx+5q82hgs0ugjQsry8nPynSnHgK0asamqBEz2tdwNOHQ8C26B2F6AgWDAaNIByZBXUe9AoG2DCoG4Oabrunb6V3YJZfQT7pcIAhkEWUglke563o+qEgU6fIoCrOkxjADs+DBsZoWZPGqu+JmWbKxsZddMAmWgK3Hs+xAbpAXGADc9eOP6Oa57axAAZUl47pFrekWBZPAoT9ubHoBLq7Yxc3sctg6+CGXZBAwNa7qWfGarqmyursgboSt1QgA
-     * @example
-     * const myObject: RequireAtLeastOne<{a: string, b: string}> = {a: 'foo'}; // valid
-     * const myObject2: RequireAtLeastOne<{a: string, b: string}> = {b: 'foo'}; // valid
-     * const myObject3: RequireAtLeastOne<{a: string, b: string}> = {a: 'foo', b: 'bar'}; // valid
-     *
-     * const myObject4: RequireAtLeastOne<{a: string, b: string}> = {}; // invalid
-     */
-    type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
-        [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
-    }[Keys];
-    /**
-     * Helper to declare an object that has only one of the keys of the original object as required
-     * @example
-     * const myObject: RequireOnlyOne<{a: string, b: string}> = {a: 'foo'}; // valid
-     * const myObject2: RequireOnlyOne<{a: string, b: string}> = {b: 'foo'}; // valid
-     *
-     * const myObject3: RequireOnlyOne<{a: string, b: string}> = {a: 'foo', b: 'bar'}; // invalid
-     */
-    type RequireOnlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
-        [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
-    }[Keys];
-    /**
-     * An Helper that given the type of an object, returns the type of the values of the object
-     *
-     * This is an useful alternative to typescripts enums, making your code as type safe as enums but without the typescript exclusive declaration and syntax
-     *
-     * Projects are free to decide wheter or not they wish to allow enums in their code base but we suggest being aware of the pitfalls of enums and double check the official documentation before making a decision
-     *
-     * https://www.typescriptlang.org/docs/handbook/enums.html#objects-vs-enums
-     *
-     * > The biggest argument in favour of this format over TypeScript's enum is that it keeps your codebase aligned with the state of JavaScript, and when/if enums are added to JavaScript then you can move to the additional syntax.
-     *
-     * https://github.com/tc39/proposal-type-annotations?tab=readme-ov-file#intentional-omissions
-     * @example
-     * type MyObject = {a: string, b: number};
-     * type MyObjectValues = ObjectValues<MyObject>; // MyObjectValues = string | number
-     * @example
-     * const myEnumLikeObject = {
-     *   a: 'foo',
-     *   b: 'bar'
-     * } as const;
-     *
-     * type myEnumLikeObjectValues = TypescriptHelpersT.ObjectValues<typeof myEnumLikeObject>; // myEnumLikeObjectValues = 'foo' | 'bar'
-     * const foo: myEnumLikeObjectValues = 'foo'; // valid
-     * const foo2: myEnumLikeObjectValues = 'bar'; // valid
-     *
-     * const foo3: myEnumLikeObjectValues = 'baz'; // invalid
-     */
-    type ObjectValues<T> = T[keyof T];
-    /**
-     * A type that represents an object in which every key starts with "data-" and the value is a string, useful for declaring the data-* attributes of an HTML element
-     * @example
-     * const myObject: DataProps = { 'data-foo': 'bar' }; // valid
-     *
-     * const myObject2: DataProps = { 'aria-foo': 123 }; // invalid
-     * const myObject3: DataProps = { 'foo': 'bar' }; // invalid
-     */
-    type DataProps = {
-        [key in `data-${string}`]: string;
-    };
-    /**
-     * A type that represents an object in which every key starts with "aria-" and the value is a string, useful for declaring the aria-* attributes of an HTML element
-     * @example
-     * const myObject: AriaProps = { 'aria-foo': 'bar' }; // valid
-     *
-     * const myObject2: AriaProps = { 'data-foo': 123 }; // invalid
-     * const myObject3: AriaProps = { 'foo': 'bar' }; // invalid
-     */
-    type AriaProps = {
-        [key in `aria-${string}`]: string;
-    };
-    /**
-     * A type that represents an object in which every key starts with "data-" or "aria-" and the value is a string, useful for declaring the aria-* and data-* attributes of an HTML element
-     * @example
-     * const myObject: AriaAndDataProps = { 'aria-foo': 'bar' }; // valid
-     * const myObject2: AriaAndDataProps = { 'data-foo': 'bar' }; // valid
-     * const myObject3: AriaAndDataProps = { 'aria-foo': 'bar', 'data-foo': 'bar' }; // valid
-     *
-     * const myObject4: AriaAndDataProps = { 'foo': 'bar' }; // invalid
-     */
-    type AriaAndDataProps = {
-        [key in `data-${string}` | `aria-${string}`]: string;
-    };
-    /**
-     * Type helper that excludes keys from one type that exist in another.
-     * @example
-     * type MyType = ExcludeKeys<{a: string, b: number}, {a: string}>; // MyType = {b: number}
-     * type MyType2 = ExcludeKeys<{a: string, b: number}, {a: string, b: number}>; // MyType2 = {}
-     * type MyType3 = ExcludeKeys<{a: string, b: number}, {c: string}>; // MyType3 = {a: string, b: number}
-     */
-    type ExcludeKeys<T, U> = {
-        [K in keyof T as K extends keyof U ? never : K]: T[K];
-    };
-    /** ***************************************************************************
-     *                            Template Literals
-     *                     Snake, Camel, Pascal, Kebab Case
-     * https://stackoverflow.com/questions/60269936/typescript-convert-generic-object-from-snake-to-camel-case
-     * https://www.typescriptlang.org/play?#code/C4TwDgpgBAygdgQwNYQCoHsDCCC2EA22AzhADwxQQAewEcAJkVEcAE4CWcA5gHxQC8AKCixKNOoygADACQBvTgDMIrKKgC+AfXlKVUAKrqpUAPzDp8jfOxh2wBPnYAvMvGRosuAsTL6ePIygALnMYQUFQSChsPHwMNxQfcjFaBiYWDm4+IREKalTJWQU4ZVUrYtKDQLMRItQUiSYbOwdnMlQ+EygAIk1u4J7u9XkAGXQAdxUAYwQSUg7huRiCeMRE2d8A4xDc8MjoZbj0AAVZmcIN5PzG5jZOXgFohFt7RxdyHgjwaFOic4xDkk8uI0rdMg9+AY4DMXq13jBPvsoL9-ugEhAgQ1QRl7tknrFVu4kvpoc8Wm9XP4vlF0RgUQ5MddsXcso9mq82uQ1h5AZcEZ9qdAANIQABGCFFhPWc2BBXSLIhoSxhR0JT0GgAtKrKoZjDULHINNo5CLxZK0dziVtgqE9t8oAA5R4AFgATHaoqgkABGb2PU0SqUYy7dAAWBHw6G6fAA9DGeuH8JHNON0Kx8PRuoK1D7Xf6xYGLUSQ4nIxrU6xM7H42GI+gU2mM1mkV7vQBmfNmoNJWtJ9DltP0DW0FjRqBxhN1hvp+iaEfAZv21vOzuF9E90v9itD+f9AA+UAA5Ip0P3xaxhxAWIfq5O+9PZ7uoAfuif6+e51eF9nWwBWVfmuulw4qyE4gVwP4+gAbAB3aXFIwDhhqCBwEQkwXuwRBanIDpGLe3SIRAmgoWhKiaJhmhuv0AAUSJOpCboAJQetAqC+o8tKeLEG51mOE69pGi6et6eaQpxvJzAJ9YVk2+GbgA6o2mY-u2HHcgCXgXJJm5zkQ06yeONabqgRCKTOQmsd6K5iepXHeCWU4yZmz49G+mjnnxRl1mZTYua+p4AEIIKwFlqN6-42e4GnccBCq3uBKkwZFKDRfZcwIeGxGoeh5F6fIuFSPhhEAILZSoACSRBUVAtH2vRUBMSxaiun6kKHHB2m8XJvE-q6on4isRbSmQUk+VWhl3smTmhagrodm1mkdSNxmmUpnmTfWwB6dNTWoG2rUDUc9JactXU-m2-XtScZwMg5fZjdG53zYddI3SdpBSSZD0Ci2zoHZxx08X2j2-f1ANvUDU1rYiS7Os94N-LdnX3lt+lVrtv4HcdqXvd0AASZ0tr+-XY3ZuME-d0M-r+z2kxJI0U5GX1Uz+UFY29S0fYzUYw56UEkxzQ3BpJ3PfaztOC0BIt1sz5k-fa5VwGAACuwCoPakJyOYRDcpoMwkJoKAgJo3pBFAcDKzgooqAANNruv60RRuaK6ZvgXb6hNQA8qrKtqxrUByFAADaQpQJwUBG+gihQIrfvq1EsywLZ9OkEKPAALpm3HqsJxAocZ1AnsxgAVOYSI+8A8cB1rIh18wlobCKICm+blvW6wADc5j1zrxYkM3rtgvc3ciJ7JcxuEpdl1AJdQMIc8AKIgkQ7DoHAZuYOvABuKjAObX4QPQUBgKw6CQKwwDsFeC-z7Pk9Ijn-uQA6h-H5r9vuHrGyGxAxut7XOufcUDfwNs7X0bsFQ9wbl-R2v9-5DwSmPO2IhgFETgc7RBCoPZNXEppHwr8WBH3mHieoTJJDoFFAAKwgFMfeXRAGh3DnASOf9o5qCgEnPBMU5hhwAGTDyyFnZOUUyYELfvMAunx1ADFQN7X2udviENoO-ERKUxEbGUcQp+ectH0B4EAA
-     **************************************************************************** */
-    /**
-     * Converts a string from snake_case to camelCase
-     * @example
-     * type MyType = SnakeToCamelCase<'foo_bar'>; // MyType = 'fooBar'
-     */
-    type SnakeToCamelCase<S extends string> = S extends `${infer T}_${infer U}` ? `${T}${Capitalize<SnakeToCamelCase<U>>}` : S;
-    /**
-     * Converts a string from snake_case to PascalCase
-     * @example
-     * type MyType = SnakeToPascalCase<'foo_bar'>; // MyType = 'FooBar'
-     */
-    type CamelToSnakeCase<S extends string> = S extends `${infer T}${infer U}` ? `${T extends Capitalize<T> ? '_' : ''}${Lowercase<T>}${CamelToSnakeCase<U>}` : S;
-    /**
-     * Converts a string from kebab-case to snake_case
-     * @example
-     * type MyType = KebabToSnakeCase<'foo-bar'>; // MyType = 'foo_bar'
-     */
-    type KebabToSnakeCase<S extends string> = S extends `${infer T}-${infer U}` ? `${T}_${KebabToSnakeCase<U>}` : S;
-    /**
-     * Converts a string from snake_case to kebab-case
-     * @example
-     * type MyType = SnakeToKebabCase<'foo_bar'>; // MyType = 'foo-bar'
-     */
-    type SnakeToKebabCase<S extends string> = S extends `${infer T}_${infer U}` ? `${T}-${SnakeToKebabCase<U>}` : S;
-    /**
-     * Converts a string from camelCase to PascalCase
-     * @example
-     * type MyType = CamelToPascalCase<'fooBar'>; // MyType = 'FooBar'
-     */
-    type CamelToPascalCase<S extends string> = Capitalize<S>;
-    /**
-     * Converts a string from PascalCase to camelCase
-     * @example
-     * type MyType = PascalToCamelCase<'FooBar'>; // MyType = 'fooBar'
-     */
-    type PascalToCamelCase<S extends string> = Uncapitalize<S>;
-    /**
-     * Converts a string from PascalCase to snake_case
-     * @example
-     * type MyType = PascalToSnakeCase<'FooBar'>; // MyType = 'foo_bar'
-     */
-    type PascalToSnakeCase<S extends string> = CamelToSnakeCase<Uncapitalize<S>>;
-    /**
-     * Converts a string from snake_case to PascalCase
-     * @example
-     * type MyType = SnakeToPascalCase<'foo_bar'>; // MyType = 'FooBar'
-     */
-    type SnakeToPascalCase<S extends string> = Capitalize<SnakeToCamelCase<S>>;
-    /** ***************************************************************************
-     *                            Template Literals
-     *                     Dimsum specific (internal) helpers
-     ****************************************************************************
-     */
-    type RemoveDSPrefix<S extends string> = S extends `DS${infer T}` ? T : S;
-    type PropsForGlobalOnSlots<Name extends string, Slots extends Record<string, string>> = {
-        [key in ObjectValues<Slots> as `ds${RemoveDSPrefix<Name>}${SnakeToPascalCase<KebabToSnakeCase<key>>}`]?: object | ((arg: object) => object);
-    };
-    type AriaAndDataPropsOrPropsGetter = AriaAndDataProps | (() => AriaAndDataProps);
-    type Hydraters<T, Args = unknown> = {
-        [key in keyof T as key extends string ? `get${Capitalize<key>}` : key]: (...args: Args extends Array<unknown> ? Args : Args[]) => T[key];
-    };
-}