{"version":3,"file":"notations.mjs","names":[],"sources":["../src/notations.ts"],"sourcesContent":["import {\n  CamelCase,\n  IValidation,\n  KebabCase,\n  PascalCase,\n  SnakeCase,\n} from \"@typia/interface\";\n\nimport { TypeGuardError } from \"./TypeGuardError\";\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/* ===========================================================\n    NOTATIONS (NAMING CONVENTIONS)\n      - CAMEL CASE\n      - PASCAL CASE\n      - SNAKE CASE\n      - KEBAB CASE\n      - FACTORY FUNCTIONS\n==============================================================\n    CAMEL CASE\n----------------------------------------------------------- */\n/**\n * Converts property names to camelCase.\n *\n * Transforms all property names in the object (including nested) to camelCase\n * convention. Creates a new object with renamed properties. Distinct source\n * keys that become the same destination key are rejected with an error instead\n * of silently discarding a value. This collision policy also applies to the\n * assert, is, validate, and factory variants.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertCamel} — Throws on type mismatch\n * - {@link isCamel} — Returns `null` on type mismatch\n * - {@link validateCamel} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with camelCase property names\n * @throws {Error} When two source keys become the same destination key\n */\nexport function camel<T>(input: T): CamelCase<T>;\n\n/** @internal */\nexport function camel(): never {\n  return NoTransformConfigurationError(\"notations.camel\");\n}\n\n/**\n * Converts property names to camelCase with assertion.\n *\n * Transforms all property names to camelCase with {@link assert} validation.\n * Throws {@link TypeGuardError} on type mismatch.\n *\n * Related functions:\n *\n * - {@link camel} — No validation\n * - {@link isCamel} — Returns `null` instead of throwing\n * - {@link validateCamel} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns New object with camelCase property names\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertCamel<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): CamelCase<T>;\n\n/** @internal */\nexport function assertCamel<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): CamelCase<T>;\n\n/** @internal */\nexport function assertCamel(): never {\n  return NoTransformConfigurationError(\"notations.assertCamel\");\n}\n\n/**\n * Converts property names to camelCase with type checking.\n *\n * Transforms all property names to camelCase with {@link is} validation. Returns\n * `null` on type mismatch.\n *\n * Related functions:\n *\n * - {@link camel} — No validation\n * - {@link assertCamel} — Throws instead of returning `null`\n * - {@link validateCamel} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with camelCase property names, or `null` if invalid\n */\nexport function isCamel<T>(input: T): CamelCase<T> | null;\n\n/** @internal */\nexport function isCamel<T>(input: unknown): CamelCase<T> | null;\n\n/** @internal */\nexport function isCamel(): never {\n  return NoTransformConfigurationError(\"notations.isCamel\");\n}\n\n/**\n * Converts property names to camelCase with validation.\n *\n * Transforms all property names to camelCase with {@link validate} validation.\n * Returns {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with converted object.\n *\n * Related functions:\n *\n * - {@link camel} — No validation\n * - {@link assertCamel} — Throws on first error\n * - {@link isCamel} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns Validation result containing converted object or errors\n */\nexport function validateCamel<T>(input: T): IValidation<CamelCase<T>>;\n\n/** @internal */\nexport function validateCamel<T>(input: unknown): IValidation<CamelCase<T>>;\n\n/** @internal */\nexport function validateCamel(): never {\n  return NoTransformConfigurationError(\"notations.validateCamel\");\n}\n\n/* -----------------------------------------------------------\n    PASCAL CASE\n----------------------------------------------------------- */\n/**\n * Converts property names to PascalCase.\n *\n * Transforms all property names in the object (including nested) to PascalCase\n * convention. Creates a new object with renamed properties. Distinct source\n * keys that become the same destination key are rejected with an error instead\n * of silently discarding a value. This collision policy also applies to the\n * assert, is, validate, and factory variants.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertPascal} — Throws on type mismatch\n * - {@link isPascal} — Returns `null` on type mismatch\n * - {@link validatePascal} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with PascalCase property names\n * @throws {Error} When two source keys become the same destination key\n */\nexport function pascal<T>(input: T): PascalCase<T>;\n\n/** @internal */\nexport function pascal(): never {\n  return NoTransformConfigurationError(\"notations.pascal\");\n}\n\n/**\n * Converts property names to PascalCase with assertion.\n *\n * Transforms all property names to PascalCase with {@link assert} validation.\n * Throws {@link TypeGuardError} on type mismatch.\n *\n * Related functions:\n *\n * - {@link pascal} — No validation\n * - {@link isPascal} — Returns `null` instead of throwing\n * - {@link validatePascal} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns New object with PascalCase property names\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertPascal<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): PascalCase<T>;\n\n/** @internal */\nexport function assertPascal<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): PascalCase<T>;\n\n/** @internal */\nexport function assertPascal(): never {\n  return NoTransformConfigurationError(\"notations.assertPascal\");\n}\n\n/**\n * Converts property names to PascalCase with type checking.\n *\n * Transforms all property names to PascalCase with {@link is} validation.\n * Returns `null` on type mismatch.\n *\n * Related functions:\n *\n * - {@link pascal} — No validation\n * - {@link assertPascal} — Throws instead of returning `null`\n * - {@link validatePascal} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with PascalCase property names, or `null` if invalid\n */\nexport function isPascal<T>(input: T): PascalCase<T> | null;\n\n/** @internal */\nexport function isPascal<T>(input: unknown): PascalCase<T> | null;\n\n/** @internal */\nexport function isPascal(): never {\n  return NoTransformConfigurationError(\"notations.isPascal\");\n}\n\n/**\n * Converts property names to PascalCase with validation.\n *\n * Transforms all property names to PascalCase with {@link validate} validation.\n * Returns {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with converted object.\n *\n * Related functions:\n *\n * - {@link pascal} — No validation\n * - {@link assertPascal} — Throws on first error\n * - {@link isPascal} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns Validation result containing converted object or errors\n */\nexport function validatePascal<T>(input: T): IValidation<PascalCase<T>>;\n\n/** @internal */\nexport function validatePascal<T>(input: unknown): IValidation<PascalCase<T>>;\n\n/** @internal */\nexport function validatePascal(): never {\n  return NoTransformConfigurationError(\"notations.validatePascal\");\n}\n\n/* -----------------------------------------------------------\n    SNAKE CASE\n----------------------------------------------------------- */\n/**\n * Converts property names to snake_case.\n *\n * Transforms all property names in the object (including nested) to snake_case\n * convention. Creates a new object with renamed properties. Distinct source\n * keys that become the same destination key are rejected with an error instead\n * of silently discarding a value. This collision policy also applies to the\n * assert, is, validate, and factory variants.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertSnake} — Throws on type mismatch\n * - {@link isSnake} — Returns `null` on type mismatch\n * - {@link validateSnake} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with snake_case property names\n * @throws {Error} When two source keys become the same destination key\n */\nexport function snake<T>(input: T): SnakeCase<T>;\n\n/** @internal */\nexport function snake(): never {\n  return NoTransformConfigurationError(\"notations.snake\");\n}\n\n/**\n * Converts property names to snake_case with assertion.\n *\n * Transforms all property names to snake_case with {@link assert} validation.\n * Throws {@link TypeGuardError} on type mismatch.\n *\n * Related functions:\n *\n * - {@link snake} — No validation\n * - {@link isSnake} — Returns `null` instead of throwing\n * - {@link validateSnake} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns New object with snake_case property names\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertSnake<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): SnakeCase<T>;\n\n/** @internal */\nexport function assertSnake<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): SnakeCase<T>;\n\n/** @internal */\nexport function assertSnake(): never {\n  return NoTransformConfigurationError(\"notations.assertSnake\");\n}\n\n/**\n * Converts property names to snake_case with type checking.\n *\n * Transforms all property names to snake_case with {@link is} validation.\n * Returns `null` on type mismatch.\n *\n * Related functions:\n *\n * - {@link snake} — No validation\n * - {@link assertSnake} — Throws instead of returning `null`\n * - {@link validateSnake} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with snake_case property names, or `null` if invalid\n */\nexport function isSnake<T>(input: T): SnakeCase<T> | null;\n\n/** @internal */\nexport function isSnake<T>(input: unknown): SnakeCase<T> | null;\n\n/** @internal */\nexport function isSnake(): never {\n  return NoTransformConfigurationError(\"notations.isSnake\");\n}\n\n/**\n * Converts property names to snake_case with validation.\n *\n * Transforms all property names to snake_case with {@link validate} validation.\n * Returns {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with converted object.\n *\n * Related functions:\n *\n * - {@link snake} — No validation\n * - {@link assertSnake} — Throws on first error\n * - {@link isSnake} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns Validation result containing converted object or errors\n */\nexport function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;\n\n/** @internal */\nexport function validateSnake<T>(input: unknown): IValidation<SnakeCase<T>>;\n\n/** @internal */\nexport function validateSnake(): never {\n  return NoTransformConfigurationError(\"notations.validateSnake\");\n}\n\n/* -----------------------------------------------------------\n    KEBAB CASE\n----------------------------------------------------------- */\n/**\n * Converts property names to kebab-case.\n *\n * Transforms all property names in the object (including nested) to kebab-case\n * convention. Creates a new object with renamed properties. Distinct source\n * keys that become the same destination key are rejected with an error instead\n * of silently discarding a value. This collision policy also applies to the\n * assert, is, validate, and factory variants.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertKebab} — Throws on type mismatch\n * - {@link isKebab} — Returns `null` on type mismatch\n * - {@link validateKebab} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with kebab-case property names\n * @throws {Error} When two source keys become the same destination key\n */\nexport function kebab<T>(input: T): KebabCase<T>;\n\n/** @internal */\nexport function kebab(): never {\n  return NoTransformConfigurationError(\"notations.kebab\");\n}\n\n/**\n * Converts property names to kebab-case with assertion.\n *\n * Transforms all property names to kebab-case with {@link assert} validation.\n * Throws {@link TypeGuardError} on type mismatch.\n *\n * Related functions:\n *\n * - {@link kebab} — No validation\n * - {@link isKebab} — Returns `null` instead of throwing\n * - {@link validateKebab} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns New object with kebab-case property names\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertKebab<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): KebabCase<T>;\n\n/** @internal */\nexport function assertKebab<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): KebabCase<T>;\n\n/** @internal */\nexport function assertKebab(): never {\n  return NoTransformConfigurationError(\"notations.assertKebab\");\n}\n\n/**\n * Converts property names to kebab-case with type checking.\n *\n * Transforms all property names to kebab-case with {@link is} validation.\n * Returns `null` on type mismatch.\n *\n * Related functions:\n *\n * - {@link kebab} — No validation\n * - {@link assertKebab} — Throws instead of returning `null`\n * - {@link validateKebab} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with kebab-case property names, or `null` if invalid\n */\nexport function isKebab<T>(input: T): KebabCase<T> | null;\n\n/** @internal */\nexport function isKebab<T>(input: unknown): KebabCase<T> | null;\n\n/** @internal */\nexport function isKebab(): never {\n  return NoTransformConfigurationError(\"notations.isKebab\");\n}\n\n/**\n * Converts property names to kebab-case with validation.\n *\n * Transforms all property names to kebab-case with {@link validate} validation.\n * Returns {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with converted object.\n *\n * Related functions:\n *\n * - {@link kebab} — No validation\n * - {@link assertKebab} — Throws on first error\n * - {@link isKebab} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns Validation result containing converted object or errors\n */\nexport function validateKebab<T>(input: T): IValidation<KebabCase<T>>;\n\n/** @internal */\nexport function validateKebab<T>(input: unknown): IValidation<KebabCase<T>>;\n\n/** @internal */\nexport function validateKebab(): never {\n  return NoTransformConfigurationError(\"notations.validateKebab\");\n}\n\n/* -----------------------------------------------------------\n    FACTORY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Creates reusable {@link camel} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createCamel(): never;\n\n/**\n * Creates reusable {@link camel} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createCamel<T>(): (input: T) => CamelCase<T>;\n\n/** @internal */\nexport function createCamel(): never {\n  NoTransformConfigurationError(\"notations.createCamel\");\n}\n\n/**\n * Creates reusable {@link assertCamel} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertCamel(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertCamel} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable conversion function\n */\nexport function createAssertCamel<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: T) => CamelCase<T>;\n\n/** @internal */\nexport function createAssertCamel(): never {\n  NoTransformConfigurationError(\"notations.createAssertCamel\");\n}\n\n/**\n * Creates reusable {@link isCamel} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsCamel(): never;\n\n/**\n * Creates reusable {@link isCamel} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createIsCamel<T>(): (input: T) => CamelCase<T> | null;\n\n/** @internal */\nexport function createIsCamel(): never {\n  NoTransformConfigurationError(\"notations.createIsCamel\");\n}\n\n/**\n * Creates reusable {@link validateCamel} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateCamel(): never;\n\n/**\n * Creates reusable {@link validateCamel} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createValidateCamel<T>(): (\n  input: T,\n) => IValidation<CamelCase<T>>;\n\n/** @internal */\nexport function createValidateCamel(): never {\n  NoTransformConfigurationError(\"notations.createValidateCamel\");\n}\n\n/**\n * Creates reusable {@link pascal} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createPascal(): never;\n\n/**\n * Creates reusable {@link pascal} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createPascal<T>(): (input: T) => PascalCase<T>;\n\n/** @internal */\nexport function createPascal(): never {\n  NoTransformConfigurationError(\"notations.createPascal\");\n}\n\n/**\n * Creates reusable {@link assertPascal} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertPascal(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertPascal} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable conversion function\n */\nexport function createAssertPascal<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: T) => PascalCase<T>;\n\n/** @internal */\nexport function createAssertPascal(): never {\n  NoTransformConfigurationError(\"notations.createAssertPascal\");\n}\n\n/**\n * Creates reusable {@link isPascal} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsPascal(): never;\n\n/**\n * Creates reusable {@link isPascal} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createIsPascal<T>(): (input: T) => PascalCase<T> | null;\n\n/** @internal */\nexport function createIsPascal(): never {\n  NoTransformConfigurationError(\"notations.createIsPascal\");\n}\n\n/**\n * Creates reusable {@link validatePascal} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidatePascal(): never;\n\n/**\n * Creates reusable {@link validatePascal} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createValidatePascal<T>(): (\n  input: T,\n) => IValidation<PascalCase<T>>;\n\n/** @internal */\nexport function createValidatePascal(): never {\n  NoTransformConfigurationError(\"notations.createValidatePascal\");\n}\n\n/**\n * Creates reusable {@link snake} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createSnake(): never;\n\n/**\n * Creates reusable {@link snake} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createSnake<T>(): (input: T) => SnakeCase<T>;\n\n/** @internal */\nexport function createSnake(): never {\n  NoTransformConfigurationError(\"notations.createSnake\");\n}\n\n/**\n * Creates reusable {@link assertSnake} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertSnake(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertSnake} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable conversion function\n */\nexport function createAssertSnake<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: T) => SnakeCase<T>;\n\n/** @internal */\nexport function createAssertSnake(): never {\n  NoTransformConfigurationError(\"notations.createAssertSnake\");\n}\n\n/**\n * Creates reusable {@link isSnake} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsSnake(): never;\n\n/**\n * Creates reusable {@link isSnake} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createIsSnake<T>(): (input: T) => SnakeCase<T> | null;\n\n/** @internal */\nexport function createIsSnake(): never {\n  NoTransformConfigurationError(\"notations.createIsSnake\");\n}\n\n/**\n * Creates reusable {@link validateSnake} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateSnake(): never;\n\n/**\n * Creates reusable {@link validateSnake} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createValidateSnake<T>(): (\n  input: T,\n) => IValidation<SnakeCase<T>>;\n\n/** @internal */\nexport function createValidateSnake(): never {\n  NoTransformConfigurationError(\"notations.createValidateSnake\");\n}\n\n/**\n * Creates reusable {@link kebab} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createKebab(): never;\n\n/**\n * Creates reusable {@link kebab} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createKebab<T>(): (input: T) => KebabCase<T>;\n\n/** @internal */\nexport function createKebab(): never {\n  NoTransformConfigurationError(\"notations.createKebab\");\n}\n\n/**\n * Creates reusable {@link assertKebab} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertKebab(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertKebab} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable conversion function\n */\nexport function createAssertKebab<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: T) => KebabCase<T>;\n\n/** @internal */\nexport function createAssertKebab(): never {\n  NoTransformConfigurationError(\"notations.createAssertKebab\");\n}\n\n/**\n * Creates reusable {@link isKebab} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsKebab(): never;\n\n/**\n * Creates reusable {@link isKebab} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createIsKebab<T>(): (input: T) => KebabCase<T> | null;\n\n/** @internal */\nexport function createIsKebab(): never {\n  NoTransformConfigurationError(\"notations.createIsKebab\");\n}\n\n/**\n * Creates reusable {@link validateKebab} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateKebab(): never;\n\n/**\n * Creates reusable {@link validateKebab} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createValidateKebab<T>(): (\n  input: T,\n) => IValidation<KebabCase<T>>;\n\n/** @internal */\nexport function createValidateKebab(): never {\n  NoTransformConfigurationError(\"notations.createValidateKebab\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,SAAgB,QAAe;CAC7B,OAAO,8BAA8B,iBAAiB;AACxD;;AAiCA,SAAgB,cAAqB;CACnC,OAAO,8BAA8B,uBAAuB;AAC9D;;AAwBA,SAAgB,UAAiB;CAC/B,OAAO,8BAA8B,mBAAmB;AAC1D;;AAyBA,SAAgB,gBAAuB;CACrC,OAAO,8BAA8B,yBAAyB;AAChE;;AA4BA,SAAgB,SAAgB;CAC9B,OAAO,8BAA8B,kBAAkB;AACzD;;AAiCA,SAAgB,eAAsB;CACpC,OAAO,8BAA8B,wBAAwB;AAC/D;;AAwBA,SAAgB,WAAkB;CAChC,OAAO,8BAA8B,oBAAoB;AAC3D;;AAyBA,SAAgB,iBAAwB;CACtC,OAAO,8BAA8B,0BAA0B;AACjE;;AA4BA,SAAgB,QAAe;CAC7B,OAAO,8BAA8B,iBAAiB;AACxD;;AAiCA,SAAgB,cAAqB;CACnC,OAAO,8BAA8B,uBAAuB;AAC9D;;AAwBA,SAAgB,UAAiB;CAC/B,OAAO,8BAA8B,mBAAmB;AAC1D;;AAyBA,SAAgB,gBAAuB;CACrC,OAAO,8BAA8B,yBAAyB;AAChE;;AA4BA,SAAgB,QAAe;CAC7B,OAAO,8BAA8B,iBAAiB;AACxD;;AAiCA,SAAgB,cAAqB;CACnC,OAAO,8BAA8B,uBAAuB;AAC9D;;AAwBA,SAAgB,UAAiB;CAC/B,OAAO,8BAA8B,mBAAmB;AAC1D;;AAyBA,SAAgB,gBAAuB;CACrC,OAAO,8BAA8B,yBAAyB;AAChE;;AAqBA,SAAgB,cAAqB;CACnC,8BAA8B,uBAAuB;AACvD;;AAwBA,SAAgB,oBAA2B;CACzC,8BAA8B,6BAA6B;AAC7D;;AAkBA,SAAgB,gBAAuB;CACrC,8BAA8B,yBAAyB;AACzD;;AAoBA,SAAgB,sBAA6B;CAC3C,8BAA8B,+BAA+B;AAC/D;;AAkBA,SAAgB,eAAsB;CACpC,8BAA8B,wBAAwB;AACxD;;AAwBA,SAAgB,qBAA4B;CAC1C,8BAA8B,8BAA8B;AAC9D;;AAkBA,SAAgB,iBAAwB;CACtC,8BAA8B,0BAA0B;AAC1D;;AAoBA,SAAgB,uBAA8B;CAC5C,8BAA8B,gCAAgC;AAChE;;AAkBA,SAAgB,cAAqB;CACnC,8BAA8B,uBAAuB;AACvD;;AAwBA,SAAgB,oBAA2B;CACzC,8BAA8B,6BAA6B;AAC7D;;AAkBA,SAAgB,gBAAuB;CACrC,8BAA8B,yBAAyB;AACzD;;AAoBA,SAAgB,sBAA6B;CAC3C,8BAA8B,+BAA+B;AAC/D;;AAkBA,SAAgB,cAAqB;CACnC,8BAA8B,uBAAuB;AACvD;;AAwBA,SAAgB,oBAA2B;CACzC,8BAA8B,6BAA6B;AAC7D;;AAkBA,SAAgB,gBAAuB;CACrC,8BAA8B,yBAAyB;AACzD;;AAoBA,SAAgB,sBAA6B;CAC3C,8BAA8B,+BAA+B;AAC/D"}