@cutticat/types 1.7.1

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maksim Victorovich Fomin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,127 @@
+# @cutticat/types
+
+TypeScript type library.
+
+## Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [API](#api)
+- [Documentation](#documentation)
+- [Requirements](#requirements)
+
+## Overview
+
+This library provides a set of useful TypeScript types for working with strings, objects, nullability, mutability, and HTTP. The types are optimized for strict TypeScript projects and provide compile-time type safety.
+
+## Installation
+
+```bash
+pnpm i @cutticat/types
+```
+
+## Quick start
+
+```typescript
+import type {
+  ToCamelCase,
+  ToSnakeCase,
+  DeepReadonly,
+  FullyUndefinable,
+  PathParams,
+} from "@cutticat/types"
+
+// String transformations
+type CamelCase = ToCamelCase<"hello-world"> // "helloWorld"
+type SnakeCase = ToSnakeCase<"helloWorld">   // "hello_world"
+
+// Working with objects
+type ReadonlyConfig = DeepReadonly<{ name: string; age: number }>
+type OptionalConfig = FullyUndefinable<{ name: string; age: number }>
+
+// HTTP path parameters
+type Params = PathParams<"/users/:id/posts/:postId"> // { id: string; postId: string }
+```
+
+## API
+
+### Strings
+
+**Case conversion:**
+
+- `ToCamelCase<S>` — converts to camelCase
+- `ToSnakeCase<S>` — converts to snake_case
+- `ToPascalCase<S>` — converts to PascalCase
+- `ToKebabCase<S>` — converts to kebab-case
+
+**Prefixes and suffixes:**
+
+- `RemovePrefix<T, Prefix>` — removes a prefix
+- `RemoveSuffix<T, Suffix>` — removes a suffix
+
+**Utilities:**
+
+- `ReplaceAll<S, From, To>` — replaces all occurrences of a substring
+
+### Objects
+
+- `PrefixKeys<T, Prefix>` — adds a prefix to all keys
+- `KeysStartingWith<T, Prefix>` — keys starting with a prefix
+- `Key` — any valid object key (`string | number | symbol`)
+- `OwnKey` — key type from `Reflect.ownKeys(obj)` (`string | symbol`)
+- `KeyToOwn<T>` — converts `Key` to `OwnKey` (`number` → `string`)
+- `CleanOmit<T, K>` — `Omit` without the `string` key artifact on objects with an index signature
+- `ExcludeFromProperties<T, E>` / `DeepExcludeFromProperties<T, E>` — excludes values from properties
+- `IsPlainObject<T>` — checks whether a value is a plain object
+
+### Nullability (nulls)
+
+- `DeepRequired<T>` — all properties are required
+- `DeepPartial<T>` — all properties are optional
+- `Nullish<T>` / `DeepNullish<T>` — nullable properties (null | undefined)
+- `Undefinable<T>` / `DeepUndefinable<T>` — properties allow undefined
+- `FullyUndefinable<T>` / `DeepFullyUndefinable<T>` — all properties are optional and allow undefined
+- `IsOptional<T, K>` — property `K` in `T` is declared optional
+- `HasUndefined<T>` — `undefined` is part of the value type
+- `CopyOptionalAndUndefined<Source, Target, Keys?>` — values from `Target` by key, copying optionality and `undefined` from `Source`
+
+### Mutability
+
+- `DeepReadonly<T, LocalExceptions?>` — recursively makes all properties readonly
+- `DeepWritable<T, LocalExceptions?>` — recursively removes readonly
+- `ReadonlyDate` — Date without mutation methods
+- `Immutable`, `DeepReadonlyExceptions` — exception mechanism for DeepReadonly/DeepWritable
+
+### HTTP
+
+- `HttpMethod` — union of all HTTP methods
+- `HttpStatusCode` — union of all HTTP status codes
+- `PathParams<Path>` — extracts `:param` parameters from a path string
+
+### Maybe (optional values)
+
+- `MaybePromise<T>` — value may be `Promise<T>` or synchronous `T`
+- `MaybeArray<T>` — value may be an array `T[]` or a single `T`
+
+### Common
+
+- `UnionToIntersection<Union>` — converts a union to an intersection
+- `Simplify<T>` — simplifies object type display (useful after intersections and conditional types)
+
+## Documentation
+
+Detailed documentation:
+
+- [Project structure](documents/STRUCTURE.md)
+- [Scripts](documents/SCRIPTS.md)
+- [Style guide](documents/STYLE_GUIDE.md)
+- [Contributing](documents/CONTRIBUTING.md)
+
+Full API documentation is available in JSDoc comments. Use IDE autocomplete to browse it.
+
+## Requirements
+
+- Node.js >= 22.0.0
+- pnpm >= 10.17.0
+- TypeScript >= 5.9.0

package/dist/index.d.ts

@@ -0,0 +1,396 @@
+//#region lib/http/methods.d.ts
+/**
+ * HTTP methods.
+ */
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD" | "CONNECT" | "TRACE";
+//#endregion
+//#region lib/http/path-params.d.ts
+/**
+ * Extracts path parameters from a path string.
+ *
+ * Supports path parameters in the `:paramName` format.
+ * If the path contains parameters, returns an object with parameter names as keys and `string` values.
+ * If the path has no parameters, returns `Record<string, never>`.
+ * If the path type cannot be inferred (generic `string`), returns `Record<string, string>` for compatibility.
+ *
+ * @example
+ * PathParams<"/users/:id"> // => { id: string }
+ * PathParams<"/users/:id/posts/:postId"> // => { id: string; postId: string }
+ * PathParams<"/users"> // => Record<string, never>
+ * PathParams<string> // => Record<string, string>
+ */
+type PathParams<Path extends string> = string extends Path ? Record<string, string> : Path extends `${infer _Start}:${infer Param}/${infer Rest}` ? { [K in Param]: string } & PathParams<`/${Rest}`> : Path extends `${infer _Start}:${infer Param}` ? { [K in Param]: string } : Record<string, never>;
+//#endregion
+//#region lib/http/status-codes.d.ts
+/**
+ * HTTP status codes.
+ *
+ * Includes all standard HTTP codes:
+ * - 1xx: Informational
+ * - 2xx: Success
+ * - 3xx: Redirection
+ * - 4xx: Client error
+ * - 5xx: Server error
+ */
+type HttpStatusCode = 100 | 101 | 102 | 103 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+//#endregion
+//#region lib/mutability/exceptions.d.ts
+/**
+ * Symbol for marking a type as Immutable.
+ */
+declare const IsImmutable: unique symbol;
+/**
+ * Type marker for Immutable.
+ */
+interface Immutable {
+  [IsImmutable]: true;
+}
+/**
+ * Types to exclude from deep readonly.
+ * Extend via declaration merging.
+ */
+interface DeepReadonlyExceptions {}
+//#endregion
+//#region lib/mutability/readonly/common.d.ts
+/**
+ * Recursively makes all object properties readonly.
+ *
+ * @param T — object whose properties become readonly
+ * @returns object with all properties readonly
+ */
+type DeepReadonly<T, LocalExceptions = never> = IsDeepReadonlyException<T, LocalExceptions> extends true ? T : T extends Immutable ? T : T extends ((...args: any[]) => any) ? T : T extends readonly [...infer R] ? { readonly [K in keyof R]: DeepReadonly<R[K], LocalExceptions> } : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<DeepReadonly<K, LocalExceptions>, DeepReadonly<V, LocalExceptions>> : T extends ReadonlySet<infer E> ? ReadonlySet<DeepReadonly<E, LocalExceptions>> : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K], LocalExceptions> } : T;
+type IsDeepReadonlyException<T, LocalExceptions = never> = [T] extends [LocalExceptions] ? true : T extends {
+  constructor: infer C;
+} ? C extends keyof DeepReadonlyExceptions ? true : false : false;
+//#endregion
+//#region lib/objects/keys.d.ts
+/**
+ * Adds a prefix to all keys of an object.
+ *
+ * @param T — object whose keys receive the prefix
+ * @param Prefix — prefix to prepend to keys
+ * @returns object with prefixed keys
+ */
+type PrefixKeys<T extends Record<string, unknown>, Prefix extends string = ""> = { [K in keyof T & string as `${Prefix}${K}`]: T[K] };
+/**
+ * Gets object keys that start with the given prefix.
+ *
+ * @param T — object whose keys are filtered
+ * @param Prefix — prefix to match
+ * @returns keys starting with the prefix
+ */
+type KeysStartingWith<T, Prefix extends string> = Extract<keyof T, `${Prefix}${string}`>;
+/**
+ * Any valid key when accessing an object property.
+ * Use when describing keys that may be a string, number (index), or symbol.
+ *
+ * @example
+ * ```ts
+ * const key: Key = "foo"
+ * const key2: Key = Symbol("bar")
+ * ```
+ */
+type Key = string | number | symbol;
+/**
+ * Key type returned by `Reflect.ownKeys(obj)`.
+ * Strings (including numeric indices like "0") and symbols — no separate `number`,
+ * because numeric keys are enumerated as strings.
+ *
+ * @example
+ * ```ts
+ * const keys: OwnKey[] = Reflect.ownKeys({ a: 1, [Symbol()]: 2 })
+ * ```
+ */
+type OwnKey = string | symbol;
+/**
+ * Converts `Key` to the corresponding `OwnKey`.
+ * `number` → `string` (numeric indices are enumerated as strings),
+ * `string` and `symbol` are unchanged.
+ *
+ * @example
+ * ```ts
+ * type A = KeyToOwn<number>   // string
+ * type B = KeyToOwn<"foo">    // "foo"
+ * type C = KeyToOwn<symbol>   // symbol
+ * ```
+ */
+type KeyToOwn<T extends Key> = T extends number ? string : T;
+/**
+ * `Omit` that removes the wide `string` key from the type before excluding keys.
+ * That key appears on objects with a string index signature (`[key: string]: …`).
+ * The result is cleaner and more predictable than plain `Omit<T, K>`.
+ *
+ * @param T — object to omit keys from
+ * @param K — keys to drop
+ */
+type CleanOmit<T, K$1 extends Key> = Omit<{ [P in keyof T as string extends P ? never : P]: T[P] }, K$1>;
+//#endregion
+//#region lib/mutability/readonly/dates.d.ts
+/**
+ * Read-only Date without mutation methods.
+ */
+type ReadonlyDate = Omit<Date, KeysStartingWith<Date, "set">>;
+//#endregion
+//#region lib/mutability/writable/common.d.ts
+/**
+ * Recursively makes all object properties writable.
+ * Removes readonly modifiers at every level.
+ */
+type DeepWritable<T, LocalExceptions = never> = IsDeepWritableException<T, LocalExceptions> extends true ? T : T extends Immutable ? T : T extends ((...args: any[]) => any) ? T : T extends readonly [...infer R] ? { -readonly [K in keyof R]: DeepWritable<R[K], LocalExceptions> } : T extends ReadonlyMap<infer K, infer V> ? Map<DeepWritable<K, LocalExceptions>, DeepWritable<V, LocalExceptions>> : T extends ReadonlySet<infer E> ? Set<DeepWritable<E, LocalExceptions>> : T extends object ? { -readonly [K in keyof T]: DeepWritable<T[K], LocalExceptions> } : T;
+type IsDeepWritableException<T, LocalExceptions = never> = [T] extends [LocalExceptions] ? true : T extends {
+  constructor: infer C;
+} ? C extends keyof DeepReadonlyExceptions ? true : false : false;
+//#endregion
+//#region lib/nulls/checks.d.ts
+/**
+ * Checks whether property `K` in `T` is declared optional.
+ *
+ * @typeParam T — object type
+ * @typeParam K — key from `T`
+ */
+type IsOptional<T, K$1 extends keyof T> = Partial<Pick<T, K$1>> extends Pick<T, K$1> ? true : false;
+/**
+ * True if `undefined` is part of type `T` (including from an optional property).
+ *
+ * @typeParam T — property value type
+ */
+type HasUndefined<T> = undefined extends T ? true : false;
+//#endregion
+//#region lib/common.d.ts
+/**
+ * Converts a union to an intersection.
+ *
+ * @param Union — union to convert
+ * @returns intersection derived from the union
+ * @example
+ * type Union = "a" | "b" | "c"
+ * type Intersection = UnionToIntersection<Union> // "a" & "b" & "c"
+ */
+type UnionToIntersection<Union> = (Union extends any ? (arg: Union) => void : never) extends ((arg: infer Intersection) => void) ?
+// Order matters here - do not swap Intersection and Union
+Intersection & Union : never;
+/**
+ * Flattens an object type to the same keys and properties (often simplifies display of
+ * intersections and conditional types in editor tooltips).
+ *
+ * @typeParam T — object type to simplify
+ */
+type Simplify<T> = { [K in keyof T]: T[K] };
+//#endregion
+//#region lib/nulls/copying.d.ts
+/**
+ * For keys from `Source` and `Target`, builds a type with values from `Target`, copying from `Source`
+ * required/optional field status and adding `| undefined` to the value where `Source`
+ * allows `undefined` for the property.
+ *
+ * @typeParam Source — template type for optionality and `undefined`
+ * @typeParam Target — result value type
+ * @typeParam Keys — subset of shared keys (defaults to intersection of `Source` and `Target` keys)
+ */
+type CopyOptionalAndUndefined<Source, Target, Keys extends keyof Source & keyof Target = keyof Source & keyof Target> = Simplify<{ [K in Keys as IsOptional<Source, K> extends true ? never : K]: HasUndefined<Source[K]> extends true ? Target[K] | undefined : Target[K] } & { [K in Keys as IsOptional<Source, K> extends true ? K : never]?: HasUndefined<Source[K]> extends true ? Target[K] | undefined : Target[K] }>;
+//#endregion
+//#region lib/nulls/nullish.d.ts
+/**
+ * Makes all object properties nullable (may be null or undefined).
+ *
+ * @param T — object whose properties to make nullable
+ * @returns object with all nullable properties
+ */
+type Nullish<T> = T extends object ? { [K in keyof T]?: T[K] | undefined | null } : T | undefined | null;
+/**
+ * Recursively makes all object properties nullable (may be null or undefined).
+ *
+ * @param T — object whose properties to make recursively nullable
+ * @returns object with all recursively nullable properties
+ */
+type DeepNullish<T> = T extends object ? { [K in keyof T]?: DeepNullish<T[K]> | undefined | null } : T | undefined | null;
+//#endregion
+//#region lib/nulls/partial.d.ts
+/**
+ * Makes all object properties optional.
+ *
+ * @param T — object whose properties to make optional
+ * @returns object with all optional properties
+ */
+type DeepPartial<T> = T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
+//#endregion
+//#region lib/nulls/required.d.ts
+/**
+ * Makes all object properties required.
+ *
+ * @param T — object whose properties to make required
+ * @returns object with all required properties
+ */
+type DeepRequired<T> = T extends object ? { [K in keyof T]-?: DeepRequired<T[K]> } : T;
+//#endregion
+//#region lib/nulls/undefinable.d.ts
+/**
+ * Makes all object properties optional and allows undefined.
+ *
+ * @param T — object whose properties to make optional with undefined
+ * @returns object with all optional properties allowing undefined
+ */
+type FullyUndefinable<T> = Partial<Undefinable<T>>;
+/**
+ * Recursively makes all object properties optional and allows undefined.
+ *
+ * @param T — object whose properties to make recursively optional with undefined
+ * @returns object with all recursively optional properties allowing undefined
+ */
+type DeepFullyUndefinable<T> = DeepPartial<DeepUndefinable<T>>;
+/**
+ * Makes all object properties allow undefined.
+ *
+ * @param T — object whose properties to allow undefined
+ * @returns object with all properties allowing undefined
+ */
+type Undefinable<T> = T extends object ? { [K in keyof T]: T[K] | undefined } : T | undefined;
+/**
+ * Recursively makes all object properties allow undefined.
+ *
+ * @param T — object whose properties to recursively allow undefined
+ * @returns object with all recursively undefined-allowing properties
+ */
+type DeepUndefinable<T> = T extends object ? { [K in keyof T]: DeepUndefinable<T[K]> } : T | undefined;
+//#endregion
+//#region lib/objects/properties.d.ts
+/**
+ * Excludes specified values from object properties.
+ *
+ * @param T — object whose property values are filtered
+ * @param E — values to exclude
+ * @returns object with excluded values removed from properties
+ */
+type ExcludeFromProperties<T, E$1> = T extends object ? { [K in keyof T]: Exclude<T[K], E$1> } : T;
+/**
+ * Recursively excludes specified values from all object properties.
+ *
+ * @param T — object whose property values are filtered
+ * @param E — values to exclude
+ * @returns object with excluded values removed from properties at all levels
+ */
+type DeepExcludeFromProperties<T, E$1> = T extends object ? { [K in keyof T]: Exclude<DeepExcludeFromProperties<T[K], E$1>, E$1> } : T;
+//#endregion
+//#region lib/objects/traits.d.ts
+/**
+ * Checks whether a value is a plain object (not an array or function).
+ *
+ * @param T — value to check
+ * @returns `true` if the value is a plain object, otherwise `false`
+ */
+type IsPlainObject<T> = T extends readonly unknown[] ? false : T extends Function ? false : T extends object ? true : false;
+//#endregion
+//#region lib/strings/misc.d.ts
+/**
+ * Replaces all occurrences of a substring with another substring.
+ *
+ * @param S — string in which to replace
+ * @param From — substring to replace
+ * @param To — replacement substring
+ * @returns string with all replacements applied
+ */
+type ReplaceAll<S extends string, From extends string, To extends string> = From extends "" ? S : S extends `${infer Head}${From}${infer Tail}` ? `${Head}${To}${ReplaceAll<Tail, From, To>}` : S;
+//#endregion
+//#region lib/strings/cases.d.ts
+/**
+ * Converts a string to kebab-case.
+ *
+ * @param S — string to convert
+ * @returns string in kebab-case
+ */
+type ToKebabCase<S extends string> = ReplaceAll<S, "_", "-">;
+/**
+ * Converts a string to snake_case (supports kebab, snake, and camel input).
+ *
+ * @param S — string to convert
+ * @param Acc — accumulated string (internal parameter)
+ * @returns string in snake_case
+ */
+type ToSnakeCase<S extends string, Acc extends string = ""> = S extends `${infer First}-${infer Rest}` ? `${ToSnakeCase<First>}_${ToSnakeCase<Rest>}` : S extends `${infer First}_${infer Rest}` ? `${ToSnakeCase<First>}_${ToSnakeCase<Rest>}` : S extends `${infer First}${infer Rest}` ? First extends Uppercase<First> ? ToSnakeCase<Rest, `${Acc extends "" ? "" : `${Acc}_`}${Lowercase<First>}`> : ToSnakeCase<Rest, `${Acc}${First}`> : `${Acc}${S}`;
+/**
+ * Converts a string to camelCase (supports kebab, snake, and camel input).
+ *
+ * @param S — string to convert
+ * @returns string in camelCase
+ */
+type ToCamelCase<S extends string> = S extends `${infer First}-${infer Rest}` ? `${ToCamelCase<First>}${ToPascalCase<Rest>}` : S extends `${infer First}_${infer Rest}` ? `${ToCamelCase<First>}${ToPascalCase<Rest>}` : S extends `${infer Head}${infer Tail}` ? Head extends Uppercase<Head> ? `${Lowercase<Head>}${ToCamelCase<Tail>}` : S : S;
+/**
+ * Converts a string to PascalCase (supports kebab, snake, and camel input).
+ *
+ * @param S — string to convert
+ * @returns string in PascalCase
+ */
+type ToPascalCase<S extends string> = Capitalize<ToCamelCase<S>>;
+//#endregion
+//#region lib/strings/parts.d.ts
+/**
+ * Removes a prefix from a string.
+ *
+ * @param T — string to remove the prefix from
+ * @param Prefix — prefix to remove
+ * @returns string without the prefix
+ */
+type RemovePrefix<T, Prefix extends string> = T extends `${Prefix}${infer Suffix}` ? Suffix : T;
+/**
+ * Removes a suffix from a string.
+ *
+ * @param T — string to remove the suffix from
+ * @param Suffix — suffix to remove
+ * @returns string without the suffix
+ */
+type RemoveSuffix<T, Suffix extends string> = T extends `${infer Prefix}${Suffix}` ? Prefix : T;
+//#endregion
+//#region lib/logging.d.ts
+/**
+ * Minimal logger interface with five standard logging levels.
+ * Compatible with `console`, Winston, Pino, Bunyan, and most other loggers.
+ *
+ * @example
+ * // Using with console
+ * const logger: Logger = console
+ *
+ * @example
+ * // Using with a library logger
+ * const logger: Logger = pino()
+ */
+type Logger = {
+  /** Trace-level logging (most verbose) */
+  trace(message: string, ...args: unknown[]): void;
+  /** Debug-level logging */
+  debug(message: string, ...args: unknown[]): void;
+  /** Info-level logging (general information) */
+  info(message: string, ...args: unknown[]): void;
+  /** Warn-level logging (warnings) */
+  warn(message: string, ...args: unknown[]): void;
+  /** Error-level logging (errors) */
+  error(message: string, ...args: unknown[]): void;
+};
+//#endregion
+//#region lib/maybe.d.ts
+/**
+ * A value that may be either `Promise<T>` or synchronous `T`.
+ * Useful for functions that may return results synchronously or asynchronously.
+ *
+ * @example
+ * ```ts
+ * type Result = MaybePromise<string>
+ * const sync: Result = "hello"
+ * const async: Result = Promise.resolve("hello")
+ * ```
+ */
+type MaybePromise<T> = Promise<T> | T;
+/**
+ * A value that may be either an array `T[]` or a single element `T`.
+ * Convenient for APIs that accept one value or several.
+ *
+ * @example
+ * ```ts
+ * type Ids = MaybeArray<string>
+ * const single: Ids = "abc"
+ * const multiple: Ids = ["abc", "def"]
+ * ```
+ */
+type MaybeArray<T> = T[] | T;
+//#endregion
+export { CleanOmit, CopyOptionalAndUndefined, DeepExcludeFromProperties, DeepFullyUndefinable, DeepNullish, DeepPartial, DeepReadonly, DeepReadonlyExceptions, DeepRequired, DeepUndefinable, DeepWritable, ExcludeFromProperties, FullyUndefinable, HasUndefined, HttpMethod, HttpStatusCode, Immutable, IsImmutable, IsOptional, IsPlainObject, Key, KeyToOwn, KeysStartingWith, Logger, MaybeArray, MaybePromise, Nullish, OwnKey, PathParams, PrefixKeys, ReadonlyDate, RemovePrefix, RemoveSuffix, ReplaceAll, Simplify, ToCamelCase, ToKebabCase, ToPascalCase, ToSnakeCase, Undefinable, UnionToIntersection };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../lib/http/methods.ts","../lib/http/path-params.ts","../lib/http/status-codes.ts","../lib/mutability/exceptions.ts","../lib/mutability/readonly/common.ts","../lib/objects/keys.ts","../lib/mutability/readonly/dates.ts","../lib/mutability/writable/common.ts","../lib/nulls/checks.ts","../lib/common.ts","../lib/nulls/copying.ts","../lib/nulls/nullish.ts","../lib/nulls/partial.ts","../lib/nulls/required.ts","../lib/nulls/undefinable.ts","../lib/objects/properties.ts","../lib/objects/traits.ts","../lib/strings/misc.ts","../lib/strings/cases.ts","../lib/strings/parts.ts","../lib/logging.ts","../lib/maybe.ts"],"sourcesContent":[],"mappings":";;AAGA;;KAAY,UAAA;;;;AAAZ;;;;ACWA;;;;;;;;;AAMQ,KANI,UAMJ,CAAA,aAAA,MAAA,CAAA,GAAA,MAAA,SANqD,IAMrD,GALJ,MAKI,CAAA,MAAA,EAAA,MAAA,CAAA,GAJJ,IAII,SAAA,GAAA,KAAA,OAAA,IAAA,KAAA,MAAA,IAAA,KAAA,KAAA,EAAA,GAAA,QAHM,KAGA,GAAA,MAAA,KAHmB,eAAe,UAC1C,wDACU,mBACR;;;;ADjBR;;;;ACWA;;;;;AAGgD,KCPpC,cAAA,GDOoC,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA;;;;ADdhD;;cGAa;;AFWb;;AACI,UEPa,SAAA,CFOb;EACA,CEPD,WAAA,CFOC,EAAA,IAAA;;;;;;AAII,UEHS,sBAAA,CFGT;;;ADjBR;;;;ACWA;;AACI,KGNQ,YHMR,CAAA,CAAA,EAAA,kBAAA,KAAA,CAAA,GGJF,uBHIE,CGJsB,CHItB,EGJyB,eHIzB,CAAA,SAAA,IAAA,GGHE,CHGF,GGDE,CHCF,SGDY,SHCZ,GGAI,CHAJ,GGGI,CHHJ,UAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAAA,GAAA,IGIM,CHJN,GGMM,CHNN,SAAA,SAAA,CAAA,GAAA,KAAA,EAAA,CAAA,GAAA,iBACA,MGM+B,CHN/B,GGMmC,YHNnC,CGMgD,CHNhD,CGMkD,CHNlD,CAAA,EGMsD,eHNtD,CAAA,EACU,GGOF,CHPE,SGOQ,WHPR,CAAA,KAAA,EAAA,EAAA,KAAA,EAAA,CAAA,GGQA,WHRA,CGQY,YHRZ,CGQyB,CHRzB,EGQ4B,eHR5B,CAAA,EGQ8C,YHR9C,CGQ2D,CHR3D,EGQ8D,eHR9D,CAAA,CAAA,GGUA,CHVA,SGUU,WHVV,CAAA,KAAA,EAAA,CAAA,GGWE,WHXF,CGWc,YHXd,CGW2B,CHX3B,EGW8B,eHX9B,CAAA,CAAA,GGaE,CHbF,SAAA,MAAA,GAAA,iBAAkC,MGcP,CHdO,GGcH,YHdG,CGcU,CHdV,CGcY,CHdZ,CAAA,EGcgB,eHdhB,CAAA,EAAf,GGgBf,CHhBe;KGmB5B,uBHlBC,CAAA,CAAA,EAAA,kBAAA,KAAA,CAAA,GAAA,CGoBH,CHnBa,CACR,SAAA,CGkBO,eHlBP,CAAA,GAAA,IAAA,GGqBF,CHrBE,SAAA;EAAM,WAAA,EAAA,KAAA,EAAA;oBGsBU;;;;AJvCxB;;;;ACWA;;AACI,KIRQ,UJQR,CAAA,UIR6B,MJQ7B,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,eAAA,MAAA,GAAA,EAAA,CAAA,GAAA,QACA,MIRU,CJQV,GAAA,MAAA,IAAA,GIR2B,MJQ3B,GIRoC,CJQpC,EAAA,GIR0C,CJQ1C,CIR4C,CJQ5C,CAAA,EACU;;;;;;;;KICF,6CAA6C,cAAc,MAAM;;AHR7E;;;;ACPA;AAKA;AASA;;;KEaY,GAAA;ADrBZ;;;;;;;;;;AAYU,KCqBE,MAAA,GDrBF,MAAA,GAAA,MAAA;;;;;;;;;;;;;AAIkD,KC+BhD,QD/BgD,CAAA,UC+B7B,GD/B6B,CAAA,GC+BtB,CD/BsB,SAAA,MAAA,GAAA,MAAA,GC+BM,CD/BN;;;;;;;;;AAMnB,KCmC7B,SDnC6B,CAAA,CAAA,EAAA,YCmCN,GDnCM,CAAA,GCmCC,IDnCD,CAAA,QAAiB,MCoC1C,CDpC0C,IAAA,MAAA,SCoCtB,CDpCsB,GAAA,KAAA,GCoCV,CDpCU,GCoCN,CDpCM,CCoCJ,CDpCI,CAAA,EAAE,ECqC1D,GDrC0D,CAAA;;;AJ5B5D;;;KMEY,YAAA,GAAe,KAAK,MAAM,iBAAiB;;;ANFvD;;;;ACWY,KMPA,YNOU,CAAA,CAAA,EAAA,kBAAA,KAAA,CAAA,GMLpB,uBNKoB,CMLI,CNKJ,EMLO,eNKP,CAAA,SAAA,IAAA,GMJhB,CNIgB,GMFhB,CNEgB,SMFN,SNEM,GMDd,CNCc,GMEd,CNFc,UAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAAA,GAAA,IMGZ,CNHY,GMKZ,CNLY,SAAA,SAAA,CAAA,GAAA,KAAA,EAAA,CAAA,GAAA,kBAAuC,MMMzB,CNNyB,GMMrB,YNNqB,CMMR,CNNQ,CMMN,CNNM,CAAA,EMMF,eNNE,CAAA,EACzD,GMOQ,CNPR,SMOkB,WNPlB,CAAA,KAAA,EAAA,EAAA,KAAA,EAAA,CAAA,GMQU,GNRV,CMQc,YNRd,CMQ2B,CNR3B,EMQ8B,eNR9B,CAAA,EMQgD,YNRhD,CMQ6D,CNR7D,EMQgE,eNRhE,CAAA,CAAA,GMUU,CNVV,SMUoB,WNVpB,CAAA,KAAA,EAAA,CAAA,GMWY,GNXZ,CMWgB,YNXhB,CMW6B,CNX7B,EMWgC,eNXhC,CAAA,CAAA,GMaY,CNbZ,SAAA,MAAA,GAAA,kBACA,MMcsC,CNdtC,GMc0C,YNd1C,CMcuD,CNdvD,CMcyD,CNdzD,CAAA,EMc6D,eNd7D,CAAA,EACU,GMgBI,CNhBJ;KMmBT,uBNnB2C,CAAA,CAAA,EAAA,kBAAA,KAAA,CAAA,GAAA,CMqB/C,CNrBgC,CAC3B,SAAA,CMoBO,eNpBP,CAAA,GAAA,IAAA,GMuBF,CNvBE,SAAA;EACU,WAAA,EAAA,KAAA,EAAA;CACR,GAAA,CAAA,SAAA,MMsBc,sBNtBd,GAAA,IAAA,GAAA,KAAA,GAAA,KAAA;;;;ADjBR;;;;ACWA;AAA6D,KORjD,UPQiD,CAAA,CAAA,EAAA,YAAA,MORnB,CPQmB,CAAA,GORd,OPQc,CORN,IPQM,CORD,CPQC,EORE,GPQF,CAAA,CAAA,SORc,IPQd,CORmB,CPQnB,EORsB,GPQtB,CAAA,GAAA,IAAA,GAAA,KAAA;;;;;;AAIvD,KOLM,YPKN,CAAA,CAAA,CAAA,GAAA,SAAA,SOL0C,CPK1C,GAAA,IAAA,GAAA,KAAA;;;;ADfN;;;;ACWA;;;;AAGc,KQRF,mBRQE,CAAA,KAAA,CAAA,GAAA,CQNX,KRMW,SAAA,GAAA,GAAA,CAAA,GAAA,EQNe,KRMf,EAAA,GAAA,IAAA,GAAA,KAAA,CAAA,UAAA,CAAA,GAAA,EAAA,KAAA,aAAA,EAAA,GAAA,IAAA;AAAA;AQJR,YRI0C,GQJ3B,KRI2B,GAAA,KAAA;;;;;;;KQKpC,4BACE,IAAI,EAAE,IPbpB;;;;;;ADIA;;;;;;AAGiC,KSLrB,wBTKqB,CAAA,MAAA,EAAA,MAAA,EAAA,aAAA,MSFZ,MTEY,GAAA,MSFG,MTEH,GAAA,MSFkB,MTElB,GAAA,MSFiC,MTEjC,CAAA,GSD7B,QTC6B,CAAA,QSEvB,ITDJ,ISCY,UTDZ,CSCuB,MTDvB,ESC+B,CTD/B,CAAA,SAAA,IAAA,GAAA,KAAA,GSCyD,CTDzD,GSC6D,YTD7D,CSEA,MTFA,CSEO,CTFP,CAAA,CAAA,SAAA,IAAA,GSIE,MTJF,CSIS,CTJT,CAAA,GAAA,SAAA,GSKE,MTLF,CSKS,CTLT,CAAA,EACU,GAAA,QSON,ITNF,ISMU,UTNV,CSMqB,MTNrB,ESM6B,CTN7B,CAAA,SAAA,IAAA,GSM+C,CTN/C,GAAA,KAAA,ISM4D,YTN5D,CSOF,MTPE,CSOK,CTPL,CAAA,CAAA,SAAA,IAAA,GSSA,MTTA,CSSO,CTTP,CAAA,GAAA,SAAA,GSUA,MTVA,CSUO,CTVP,CAAA,EAAM,CAAA;;;;ADjBd;;;;ACWA;AAA6D,KURjD,OVQiD,CAAA,CAAA,CAAA,GURpC,CVQoC,SAAA,MAAA,GAAA,QACzD,MURc,CVQd,IURmB,CVQnB,CURqB,CVQrB,CAAA,GAAA,SAAA,GAAA,IAAA,EACA,GURA,CVQA,GAAA,SAAA,GAAA,IAAA;;;;;;;AAIU,KUJF,WVIE,CAAA,CAAA,CAAA,GUJe,CVIf,SAAA,MAAA,GAAA,cUHI,KAAK,YAAY,EAAE,2BACjC;;;;AXfJ;;;;ACWA;AAA6D,KWRjD,WXQiD,CAAA,CAAA,CAAA,GWRhC,CXQgC,SAAA,MAAA,GAAA,QACzD,MWT0D,CXS1D,IWT+D,WXS/D,CWT2E,CXS3E,CWT6E,CXS7E,CAAA,CAAA,EACA,GWVqF,CXUrF;;;;ADbJ;;;;ACWA;AAA6D,KYRjD,YZQiD,CAAA,CAAA,CAAA,GYR/B,CZQ+B,SAAA,MAAA,GAAA,QACzD,MYT2D,CZS3D,KYTiE,YZSjE,CYT8E,CZS9E,CYTgF,CZShF,CAAA,CAAA,EACA,GYVwF,CZUxF;;;ADbJ;;;;ACWA;;AACI,KaLQ,gBbKR,CAAA,CAAA,CAAA,GaL8B,ObK9B,CaLsC,WbKtC,CaLkD,CbKlD,CAAA,CAAA;;;;;;;AAKI,KaFI,oBbEJ,CAAA,CAAA,CAAA,GaF8B,WbE9B,CaF0C,ebE1C,CaF0D,CbE1D,CAAA,CAAA;;;;;ACVR;;KYkBY,iBAAiB,iCAAiC,IAAI,EAAE,gBXzBpE,GWyBuF,CXzB1E,GAAA,SAAA;AAKb;AASA;;;;ACRA;AAE0B,KUyBd,eVzBc,CAAA,CAAA,CAAA,GUyBO,CVzBP,SAAA,MAAA,GAAA,QAAG,MU0BX,CV1BW,GU0BP,eV1BO,CU0BS,CV1BT,CU0BW,CV1BX,CAAA,CAAA,EAA3B,GU2BE,CV3BF,GAAA,SAAA;;;;AJRF;;;;ACWA;;AACI,KcRQ,qBdQR,CAAA,CAAA,EAAA,GAAA,CAAA,GcRsC,CdQtC,SAAA,MAAA,GAAA,QACA,McRc,CdQd,GcRkB,OdQlB,CcR0B,CdQ1B,CcR4B,CdQ5B,CAAA,EcRgC,GdQhC,CAAA,EACU,GcRV,CdQU;;;;;;;;KcCF,oCAAkC,iCAC5B,IAAI,QAAQ,0BAA0B,EAAE,IAAI,MAAI,MbTlE,GaUI,CbVQ;;;;AFPZ;;;;ACWA;AAA6D,KeRjD,afQiD,CAAA,CAAA,CAAA,GeR9B,CfQ8B,SAAA,SAAA,OAAA,EAAA,GAAA,KAAA,GeLzD,CfKyD,SeL/C,QfK+C,GAAA,KAAA,GeHvD,CfGuD,SAAA,MAAA,GAAA,IAAA,GAAA,KAAA;;;;ADX7D;;;;ACWA;;;AAEI,KgBRQ,UhBQR,CAAA,UAAA,MAAA,EAAA,aAAA,MAAA,EAAA,WAAA,MAAA,CAAA,GgBR+E,IhBQ/E,SAAA,EAAA,GgBPA,ChBOA,GgBNA,ChBMA,SAAA,GAAA,KAAA,KAAA,GgBN0B,IhBM1B,GAAA,KAAA,KAAA,EAAA,GAAA,GgBLK,IhBKL,GgBLY,EhBKZ,GgBLiB,UhBKjB,CgBL4B,IhBK5B,EgBLkC,IhBKlC,EgBLwC,EhBKxC,CAAA,EAAA,GgBJE,ChBIF;;;ADbJ;;;;ACWA;;AACI,KiBPQ,WjBOR,CAAA,UAAA,MAAA,CAAA,GiBPwC,UjBOxC,CiBPmD,CjBOnD,EAAA,GAAA,EAAA,GAAA,CAAA;;;;;;;;AAKU,KiBFF,WjBEE,CAAA,UAAA,MAAA,EAAA,YAAA,MAAA,GAAA,EAAA,CAAA,GiBGZ,CjBHY,SAAA,GAAA,KAAA,MAAA,IAAA,KAAA,KAAA,EAAA,GAAA,GiBIL,WjBJK,CiBIO,KjBJP,CAAA,IiBIiB,WjBJjB,CiBI6B,IjBJ7B,CAAA,EAAA,GiBMR,CjBNQ,SAAA,GAAA,KAAA,MAAA,IAAA,KAAA,KAAA,EAAA,GAAA,GiBOH,WjBPG,CiBOS,KjBPT,CAAA,IiBOmB,WjBPnB,CiBO+B,IjBP/B,CAAA,EAAA,GiBSN,CjBTM,SAAA,GAAA,KAAA,MAAA,GAAA,KAAA,KAAA,EAAA,GAAA,KAAA,SiBUU,SjBVV,CiBUoB,KjBVpB,CAAA,GiBWF,WjBXE,CiBWU,IjBXV,EAAA,GiBWmB,GjBXnB,SAAA,EAAA,GAAA,EAAA,GAAA,GiBW4C,GjBX5C,GAAA,GiBWqD,SjBXrD,CiBW+D,KjBX/D,CAAA,EAAA,CAAA,GiBYF,WjBZE,CiBYU,IjBZV,EAAA,GiBYmB,GjBZnB,GiBYyB,KjBZzB,EAAA,CAAA,GAAA,GiBaD,GjBbC,GiBaK,CjBbL,EAAA;;;;ACVd;;;KgB+BY,gCAEV,8CACO,YAAY,SAAS,aAAa,UAErC,8CACK,YAAY,SAAS,aAAa,UAErC,sDACe,UAAU,WAClB,UAAU,QAAQ,YAAY,UACjC,IACF;AflDV;AAKA;AASA;;;;ACRY,KcoDA,YdpDY,CAAA,UAAA,MAAA,CAAA,GcoDqB,UdpDrB,CcoDgC,WdpDhC,CcoD4C,CdpD5C,CAAA,CAAA;;;;AJNxB;;;;ACWA;;AACI,KkBRQ,YlBQR,CAAA,CAAA,EAAA,eAAA,MAAA,CAAA,GkBRiD,ClBQjD,SAAA,GkBR8D,MlBQ9D,GAAA,KAAA,OAAA,EAAA,GAAA,MAAA,GkBNA,ClBMA;;;;;;;;AAKU,KkBFF,YlBEE,CAAA,CAAA,EAAA,eAAA,MAAA,CAAA,GkBFuC,ClBEvC,SAAA,GAAA,KAAA,OAAA,GkBFmE,MlBEnE,EAAA,GAAA,MAAA,GkBAV,ClBAU;;;;ADjBd;;;;ACWA;;;;;;;AAIM,KmBNM,MAAA,GnBMN;EACU;EACR,KAAA,CAAA,OAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EAAM;;;;ECVF;;;;ACPZ,CAAA;;;;AHAA;;;;ACWA;;;;;;AAGiC,KoBNrB,YpBMqB,CAAA,CAAA,CAAA,GoBNH,OpBMG,CoBNK,CpBML,CAAA,GoBNU,CpBMV;;;;;;;;ACPjC;;;;ACPa,KkBqBD,UlBrBmD,CAAA,CAAA,CAAA,GkBqBnC,ClBrBmC,EAAA,GkBqB7B,ClBrB6B"}

package/dist/index.js

@@ -0,0 +1,9 @@
+//#region lib/mutability/exceptions.ts
+/**
+* Symbol for marking a type as Immutable.
+*/
+const IsImmutable = Symbol("IsImmutable");
+
+//#endregion
+export { IsImmutable };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../lib/mutability/exceptions.ts"],"sourcesContent":["/**\n * Symbol for marking a type as Immutable.\n */\nexport const IsImmutable: unique symbol = Symbol(\"IsImmutable\")\n\n/**\n * Type marker for Immutable.\n */\nexport interface Immutable {\n  [IsImmutable]: true\n}\n\n/**\n * Types to exclude from deep readonly.\n * Extend via declaration merging.\n */\n// biome-ignore lint/suspicious/noEmptyInterface: Made intentionally empty\nexport interface DeepReadonlyExceptions {}\n"],"mappings":";;;;AAGA,MAAa,cAA6B,OAAO,cAAc"}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@cutticat/types",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.7.1",
+  "description": "CuttiCat Types Library",
+  "author": "Maksim Victorovich Fomin",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitflic.ru/project/cutticat-npm/types.git"
+  },
+  "keywords": [
+    "typescript",
+    "types",
+    "utility-types",
+    "generics",
+    "readonly",
+    "nullability",
+    "http",
+    "type-level",
+    "cutticat"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.13",
+    "rimraf": "^6.1.0",
+    "@types/node": "^25.0.3",
+    "tsdown": "0.19.0-beta.2",
+    "typescript": "^5.9.3"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "lint:fix:unsafe": "biome check --write --unsafe .",
+    "format": "biome format --write .",
+    "format:check": "biome format .",
+    "clean": "rimraf ./dist",
+    "build": "tsc --noEmit && tsdown"
+  }
+}