diff --git a/src/KebabCase.ts b/src/KebabCase.ts
new file mode 100644
index 0000000000..cc29b32492
--- /dev/null
+++ b/src/KebabCase.ts
@@ -0,0 +1,119 @@
+import { Equal } from "./typings/Equal";
+import { IsTuple } from "./typings/IsTuple";
+import { NativeClass } from "./typings/NativeClass";
+import { ValueOf } from "./typings/ValueOf";
+
+/**
+ * Kebab case type.
+ *
+ * `KebabCase` type is a type that all keys of an object are converted to kebab case.
+ *
+ * It also erases every method property like {@link Resolved} type.
+ *
+ * @template T Target type to be kebab cased
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type KebabCase<T> =
+  Equal<T, KebabizeMain<T>> extends true ? T : KebabizeMain<T>;
+
+/* -----------------------------------------------------------
+    OBJECT CONVERSION
+----------------------------------------------------------- */
+
+type KebabizeMain<T> = T extends [never]
+  ? never // special trick for (jsonable | null) type
+  : T extends { valueOf(): boolean | bigint | number | string }
+    ? ValueOf<T>
+    : T extends Function
+      ? never
+      : T extends object
+        ? KebabizeObject<T>
+        : T;
+
+type KebabizeObject<T extends object> =
+  T extends Array<infer U>
+    ? IsTuple<T> extends true
+      ? KebabizeTuple<T>
+      : KebabizeMain<U>[]
+    : T extends Set<infer U>
+      ? Set<KebabizeMain<U>>
+      : T extends Map<infer K, infer V>
+        ? Map<KebabizeMain<K>, KebabizeMain<V>>
+        : T extends WeakSet<any> | WeakMap<any, any>
+          ? never
+          : T extends NativeClass
+            ? T
+            : {
+                [Key in keyof T as KebabizeString<Key & string>]: KebabizeMain<
+                  T[Key]
+                >;
+              };
+
+/* -----------------------------------------------------------
+    SPECIAL CASES
+----------------------------------------------------------- */
+type KebabizeTuple<T extends readonly any[]> = T extends []
+  ? []
+  : T extends [infer F]
+    ? [KebabizeMain<F>]
+    : T extends [infer F, ...infer Rest extends readonly any[]]
+      ? [KebabizeMain<F>, ...KebabizeTuple<Rest>]
+      : T extends [(infer F)?]
+        ? [KebabizeMain<F>?]
+        : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+          ? [KebabizeMain<F>?, ...KebabizeTuple<Rest>]
+          : [];
+
+/* -----------------------------------------------------------
+    STRING CONVERTER
+----------------------------------------------------------- */
+type KebabizeString<Key extends string> = Key extends `${infer _}`
+  ? KebabizeStringRepeatedly<Key, "">
+  : Key;
+type KebabizeStringRepeatedly<
+  S extends string,
+  Previous extends string,
+> = S extends `${infer First}${infer Second}${infer Rest}`
+  ? `${Hyphen<Previous, First>}${Lowercase<First>}${Hyphen<
+      First,
+      Second
+    >}${Lowercase<Second>}${KebabizeStringRepeatedly<Rest, Second>}`
+  : S extends `${infer First}`
+    ? `${Hyphen<Previous, First>}${Lowercase<First>}`
+    : "";
+type Hyphen<First extends string, Second extends string> = First extends
+  | UpperAlphabetic
+  | ""
+  | "-"
+  | "_"
+  ? ""
+  : Second extends UpperAlphabetic
+    ? "-"
+    : "";
+type UpperAlphabetic =
+  | "A"
+  | "B"
+  | "C"
+  | "D"
+  | "E"
+  | "F"
+  | "G"
+  | "H"
+  | "I"
+  | "J"
+  | "K"
+  | "L"
+  | "M"
+  | "N"
+  | "O"
+  | "P"
+  | "Q"
+  | "R"
+  | "S"
+  | "T"
+  | "U"
+  | "V"
+  | "W"
+  | "X"
+  | "Y"
+  | "Z";
\ No newline at end of file
diff --git a/src/internal/_notationKebab.ts b/src/internal/_notationKebab.ts
new file mode 100644
index 0000000000..915c95db40
--- /dev/null
+++ b/src/internal/_notationKebab.ts
@@ -0,0 +1,52 @@
+import { __notationUnsnake } from "./private/__notationUnsnake";
+
+export const _notationKebab = (str: string): string => {
+  if (str.length === 0) return str;
+
+  // PREFIX (handle leading hyphens and underscores)
+  let prefix: string = "";
+  for (let i: number = 0; i < str.length; i++) {
+    if (str[i] === "-" || str[i] === "_") prefix += str[i];
+    else break;
+  }
+  if (prefix.length !== 0) str = str.substring(prefix.length);
+
+  const out = (s: string) => `${prefix}${s}`;
+
+  // Handle snake_case input
+  if (str.includes("_")) {
+    const items: string[] = str.split("_");
+    return out(items.map((s) => s.toLowerCase()).join("-"));
+  }
+
+  // Handle kebab-case input (already kebab)
+  if (str.includes("-")) {
+    const items: string[] = str.split("-");
+    return out(items.map((s) => s.toLowerCase()).join("-"));
+  }
+
+  // CAMEL OR PASCAL CASE
+  const indexes: number[] = [];
+  for (let i: number = 0; i < str.length; i++) {
+    const code: number = str.charCodeAt(i);
+    if (65 <= code && code <= 90) indexes.push(i);
+  }
+  for (let i: number = indexes.length - 1; i > 0; --i) {
+    const now: number = indexes[i]!;
+    const prev: number = indexes[i - 1]!;
+    if (now - prev === 1) indexes.splice(i, 1);
+  }
+  if (indexes.length !== 0 && indexes[0] === 0) indexes.splice(0, 1);
+  if (indexes.length === 0) return out(str.toLowerCase());
+
+  let ret: string = "";
+  for (let i: number = 0; i < indexes.length; i++) {
+    const first: number = i === 0 ? 0 : indexes[i - 1]!;
+    const last: number = indexes[i]!;
+
+    ret += str.substring(first, last).toLowerCase();
+    ret += "-";
+  }
+  ret += str.substring(indexes[indexes.length - 1]!).toLowerCase();
+  return out(ret);
+}
\ No newline at end of file
diff --git a/src/module.ts b/src/module.ts
index ba671d525e..64cda55104 100644
--- a/src/module.ts
+++ b/src/module.ts
@@ -30,6 +30,7 @@ export * from "./TypeGuardError";
 export * from "./Primitive";
 export * from "./Resolved";
 export * from "./CamelCase";
+export * from "./KebabCase";
 export * from "./PascalCase";
 export * from "./SnakeCase";
 export * from "./IReadableURLSearchParams";
diff --git a/src/notations.ts b/src/notations.ts
index 94a5e84454..1cdb3f3dee 100644
--- a/src/notations.ts
+++ b/src/notations.ts
@@ -2,6 +2,7 @@ import { NoTransformConfigurationError } from "./transformers/NoTransformConfigu
 
 import { CamelCase } from "./CamelCase";
 import { IValidation } from "./IValidation";
+import { KebabCase } from "./KebabCase";
 import { PascalCase } from "./PascalCase";
 import { SnakeCase } from "./SnakeCase";
 import { TypeGuardError } from "./TypeGuardError";
@@ -11,6 +12,7 @@ import { TypeGuardError } from "./TypeGuardError";
       - CAMEL CASE
       - PASCAL CASE
       - SNAKE CASE
+      - KEBAB CASE
       - FACTORY FUNCTIONS
 ==============================================================
     CAMEL CASE
@@ -435,6 +437,154 @@ export function validateSnake(): never {
   return NoTransformConfigurationError("notations.validateSnake");
 }
 
+/* -----------------------------------------------------------
+    KEBAB CASE
+----------------------------------------------------------- */
+/**
+ * Convert to kebab case.
+ *
+ * Convert every property names of nested objects to follow the kebab case convention.
+ *
+ * For reference, this `typia.notations.kebab()` function does not validate the input value
+ * type. It just believes that the input value is following the type `T`. Therefore,
+ * if you can't ensure the input value type, it would be better to call one of them below:
+ *
+ * - {@link assertKebab}
+ * - {@link isKebab}
+ * - {@link validateKebab}
+ *
+ * @template T Type of the input value
+ * @param input Target object
+ * @returns Kebab case object
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function kebab<T>(input: T): KebabCase<T>;
+
+/**
+ * @internal
+ */
+export function kebab(): never {
+  return NoTransformConfigurationError("notations.kebab");
+}
+
+/**
+ * Converts to kebab case with type assertion.
+ *
+ * Convert every property names of nested objects to follow the kebab case convention.
+ * If the input value does not follow the type `T`, it throws {@link TypeGuardError}.
+ *
+ * @template T Type of the input value
+ * @param input Target object
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
+ * @returns Kebab case object
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function assertKebab<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): KebabCase<T>;
+
+/**
+ * Converts to kebab case with type assertion.
+ *
+ * Convert every property names of nested objects to follow the kebab case convention.
+ * If the input value does not follow the type `T`, it throws {@link TypeGuardError}.
+ *
+ * @template T Type of the input value
+ * @param input Target object
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
+ * @returns Kebab case object
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function assertKebab<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): KebabCase<T>;
+
+/**
+ * @internal
+ */
+export function assertKebab(): never {
+  return NoTransformConfigurationError("notations.assertKebab");
+}
+
+/**
+ * Converts to kebab case with type checking.
+ *
+ * Convert every property names of nested objects to follow the kebab case convention.
+ * If the input value does not follow the type `T`, it returns `null` value instead.
+ *
+ * @template T Type of the input value
+ * @param input Target object
+ * @returns Kebab case object when exact type, otherwise null
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function isKebab<T>(input: T): KebabCase<T> | null;
+
+/**
+ * Converts to kebab case with type checking.
+ *
+ * Convert every property names of nested objects to follow the kebab case convention.
+ * If the input value does not follow the type `T`, it returns `null` value instead.
+ *
+ * @template T Type of the input value
+ * @param input Target object
+ * @returns Kebab case object when exact type, otherwise null
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function isKebab<T>(input: unknown): KebabCase<T> | null;
+
+/**
+ * @internal
+ */
+export function isKebab(): never {
+  return NoTransformConfigurationError("notations.isKebab");
+}
+
+/**
+ * Converts to kebab case with type validation.
+ *
+ * Convert every property names of nested objects to follow the kebab case convention.
+ * If the input value does not follow the type `T`, it returns {@link IValidation.Failure}
+ * object. Otherwise, there's no problem on the input value, kebab cased converted data
+ * would be stored in the `data` property of the output {@link IValidation.Success} object.
+ *
+ * @template T Type of the input value
+ * @param input Target object
+ * @returns Validation result with kebab case object
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function validateKebab<T>(input: T): IValidation<KebabCase<T>>;
+
+/**
+ * Converts to kebab case with type validation.
+ *
+ * Convert every property names of nested objects to follow the kebab case convention.
+ * If the input value does not follow the type `T`, it returns {@link IValidation.Failure}
+ * object. Otherwise, there's no problem on the input value, kebab cased converted data
+ * would be stored in the `data` property of the output {@link IValidation.Success} object.
+ *
+ * @template T Type of the input value
+ * @param input Target object
+ * @returns Validation result with kebab case object
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function validateKebab<T>(input: unknown): IValidation<KebabCase<T>>;
+
+/**
+ * @internal
+ */
+export function validateKebab(): never {
+  return NoTransformConfigurationError("notations.validateKebab");
+}
+
 /* -----------------------------------------------------------
     FACTORY FUNCTIONS
 ----------------------------------------------------------- */
@@ -749,3 +899,123 @@ export function createValidateSnake<T>(): (
 export function createValidateSnake(): never {
   NoTransformConfigurationError("notations.createValidateSnake");
 }
+
+/**
+ * Creates a reusable {@link kebab} function.
+ *
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until be configure the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function createKebab(): never;
+
+/**
+ * Creates a reusable {@link kebab} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `kebab` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function createKebab<T>(): (input: T) => KebabCase<T>;
+
+/**
+ * @internal
+ */
+export function createKebab(): never {
+  NoTransformConfigurationError("notations.createKebab");
+}
+
+/**
+ * Creates a reusable {@link assertKebab} function.
+ *
+ * @danger You must configure the generic argument `T`
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
+ * @returns Nothing until be configure the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function createAssertKebab(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
+
+/**
+ * Creates a reusable {@link assertKebab} function.
+ *
+ * @template T Type of the input value
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
+ * @returns A reusable `assertKebab` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function createAssertKebab<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: T) => KebabCase<T>;
+
+/**
+ * @internal
+ */
+export function createAssertKebab(): never {
+  NoTransformConfigurationError("notations.createAssertKebab");
+}
+
+/**
+ * Creates a reusable {@link isKebab} function.
+ *
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until be configure the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function createIsKebab(): never;
+
+/**
+ * Creates a reusable {@link isKebab} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `isKebab` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function createIsKebab<T>(): (input: T) => KebabCase<T> | null;
+
+/**
+ * @internal
+ */
+export function createIsKebab(): never {
+  NoTransformConfigurationError("notations.createIsKebab");
+}
+
+/**
+ * Creates a reusable {@link validateKebab} function.
+ *
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until be configure the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function createValidateKebab(): never;
+
+/**
+ * Creates a reusable {@link validateKebab} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `validateKebab` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function createValidateKebab<T>(): (
+  input: T,
+) => IValidation<KebabCase<T>>;
+
+/**
+ * @internal
+ */
+export function createValidateKebab(): never {
+  NoTransformConfigurationError("notations.createValidateKebab");
+}
diff --git a/src/transformers/CallExpressionTransformer.ts b/src/transformers/CallExpressionTransformer.ts
index dc7fbd5929..ef3a6774db 100644
--- a/src/transformers/CallExpressionTransformer.ts
+++ b/src/transformers/CallExpressionTransformer.ts
@@ -519,6 +519,15 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
     validateSnake: () =>
       NotationValidateGeneralTransformer.transform(NamingConvention.snake),
 
+    // KEBAB
+    kebab: () => NotationGeneralTransformer.transform(NamingConvention.kebab),
+    assertKebab: () =>
+      NotationAssertGeneralTransformer.transform(NamingConvention.kebab),
+    isKebab: () =>
+      NotationIsGeneralTransformer.transform(NamingConvention.kebab),
+    validateKebab: () =>
+      NotationValidateGeneralTransformer.transform(NamingConvention.kebab),
+
     // FACTORIES
     createCamel: () =>
       NotationCreateGeneralTransformer.transform(NamingConvention.camel),
@@ -550,5 +559,15 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
       NotationCreateValidateGeneralTransformer.transform(
         NamingConvention.snake,
       ),
+    createKebab: () =>
+      NotationCreateGeneralTransformer.transform(NamingConvention.kebab),
+    createAssertKebab: () =>
+      NotationCreateAssertGeneralTransformer.transform(NamingConvention.kebab),
+    createIsKebab: () =>
+      NotationCreateIsGeneralTransformer.transform(NamingConvention.kebab),
+    createValidateKebab: () =>
+      NotationCreateValidateGeneralTransformer.transform(
+        NamingConvention.kebab,
+      ),
   },
 };
diff --git a/src/utils/NamingConvention.ts b/src/utils/NamingConvention.ts
index 04be742339..20b4671d1d 100644
--- a/src/utils/NamingConvention.ts
+++ b/src/utils/NamingConvention.ts
@@ -26,6 +26,31 @@ export namespace NamingConvention {
           : out(items.map(props.snake).join(""));
     };
 
+  const unkebab =
+    (props: {
+      plain: (str: string) => string;
+      kebab: (str: string, index: number) => string;
+    }) =>
+    (str: string): string => {
+      // Handle leading hyphens (preserve them as prefix)
+      let prefix: string = "";
+      for (let i: number = 0; i < str.length; i++) {
+        if (str[i] === "-") prefix += "-";
+        else break;
+      }
+      if (prefix.length !== 0) str = str.substring(prefix.length);
+
+      const out = (s: string) => `${prefix}${s}`;
+      if (str.length === 0) return out("");
+
+      const items: string[] = str.split("-").filter((s) => s.length !== 0);
+      return items.length === 0
+        ? out("")
+        : items.length === 1
+          ? out(props.plain(items[0]!))
+          : out(items.map(props.kebab).join(""));
+    };
+
   export function snake(str: string): string {
     if (str.length === 0) return str;
 
@@ -33,13 +58,19 @@ export namespace NamingConvention {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     let prefix: string = "";
     for (let i: number = 0; i < str.length; i++) {
-      if (str[i] === "_") prefix += "_";
+      if (str[i] === "_" || str[i] === "-") prefix += str[i];
       else break;
     }
     if (prefix.length !== 0) str = str.substring(prefix.length);
 
     const out = (s: string) => `${prefix}${s}`;
 
+    // KEBAB CASE - convert to snake case
+    if (str.includes("-")) {
+      const items: string[] = str.split("-");
+      return out(items.map((s) => s.toLowerCase()).join("_"));
+    }
+
     // SNAKE CASE
     const items: string[] = str.split("_");
     if (items.length > 1)
@@ -72,6 +103,20 @@ export namespace NamingConvention {
   }
 
   export function camel(str: string) {
+    // Handle kebab-case input
+    if (str.includes("-")) {
+      return unkebab({
+        plain: (str) =>
+          str.length
+            ? str === str.toUpperCase()
+              ? str.toLocaleLowerCase()
+              : `${str[0]!.toLowerCase()}${str.substring(1)}`
+            : str,
+        kebab: (str, i) =>
+          i === 0 ? str.toLowerCase() : StringUtil.capitalize(str.toLowerCase()),
+      })(str);
+    }
+    
     return unsnake({
       plain: (str) =>
         str.length
@@ -85,10 +130,70 @@ export namespace NamingConvention {
   }
 
   export function pascal(str: string) {
+    // Handle kebab-case input
+    if (str.includes("-")) {
+      return unkebab({
+        plain: (str) =>
+          str.length ? `${str[0]!.toUpperCase()}${str.substring(1)}` : str,
+        kebab: StringUtil.capitalize,
+      })(str);
+    }
+    
     return unsnake({
       plain: (str) =>
         str.length ? `${str[0]!.toUpperCase()}${str.substring(1)}` : str,
       snake: StringUtil.capitalize,
     })(str);
   }
+
+  export function kebab(str: string): string {
+    if (str.length === 0) return str;
+
+    // PREFIX (handle leading hyphens and underscores)
+    let prefix: string = "";
+    for (let i: number = 0; i < str.length; i++) {
+      if (str[i] === "-" || str[i] === "_") prefix += str[i];
+      else break;
+    }
+    if (prefix.length !== 0) str = str.substring(prefix.length);
+
+    const out = (s: string) => `${prefix}${s}`;
+
+    // Handle snake_case input
+    if (str.includes("_")) {
+      const items: string[] = str.split("_");
+      return out(items.map((s) => s.toLowerCase()).join("-"));
+    }
+
+    // Handle kebab-case input (already kebab)
+    if (str.includes("-")) {
+      const items: string[] = str.split("-");
+      return out(items.map((s) => s.toLowerCase()).join("-"));
+    }
+
+    // CAMEL OR PASCAL CASE
+    const indexes: number[] = [];
+    for (let i: number = 0; i < str.length; i++) {
+      const code: number = str.charCodeAt(i);
+      if (65 <= code && code <= 90) indexes.push(i);
+    }
+    for (let i: number = indexes.length - 1; i > 0; --i) {
+      const now: number = indexes[i]!;
+      const prev: number = indexes[i - 1]!;
+      if (now - prev === 1) indexes.splice(i, 1);
+    }
+    if (indexes.length !== 0 && indexes[0] === 0) indexes.splice(0, 1);
+    if (indexes.length === 0) return out(str.toLowerCase());
+
+    let ret: string = "";
+    for (let i: number = 0; i < indexes.length; i++) {
+      const first: number = i === 0 ? 0 : indexes[i - 1]!;
+      const last: number = indexes[i]!;
+
+      ret += str.substring(first, last).toLowerCase();
+      ret += "-";
+    }
+    ret += str.substring(indexes[indexes.length - 1]!).toLowerCase();
+    return out(ret);
+  }
 }
diff --git a/test/build/internal/TestFeature.ts b/test/build/internal/TestFeature.ts
index dc8a53d82d..e0f8a14d86 100644
--- a/test/build/internal/TestFeature.ts
+++ b/test/build/internal/TestFeature.ts
@@ -403,7 +403,7 @@ export namespace TestFeature {
     //----
     // NOTATIONS
     //----
-    ...["camel", "pascal", "snake"]
+    ...["camel", "kebab", "pascal", "snake"]
       .map((method) =>
         ([null, "assert", "is", "validate"] as const).map((mode) => ({
           module: "notation",
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAny.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAny.ts
new file mode 100644
index 0000000000..0453548127
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAny.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayAny } from "../../structures/ArrayAny";
+
+export const test_notation_createValidateKebab_ArrayAny = (): void =>
+  _test_notation_validateGeneral("ArrayAny")<ArrayAny>(ArrayAny)<
+    typia.KebabCase<ArrayAny>
+  >({
+    convert: typia.notations.createValidateKebab<ArrayAny>(),
+    assert: typia.createAssert<typia.KebabCase<ArrayAny>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAtomicAlias.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAtomicAlias.ts
new file mode 100644
index 0000000000..2d979bf1fc
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAtomicAlias.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayAtomicAlias } from "../../structures/ArrayAtomicAlias";
+
+export const test_notation_createValidateKebab_ArrayAtomicAlias = (): void =>
+  _test_notation_validateGeneral("ArrayAtomicAlias")<ArrayAtomicAlias>(
+    ArrayAtomicAlias,
+  )<typia.KebabCase<ArrayAtomicAlias>>({
+    convert: typia.notations.createValidateKebab<ArrayAtomicAlias>(),
+    assert: typia.createAssert<typia.KebabCase<ArrayAtomicAlias>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAtomicSimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAtomicSimple.ts
new file mode 100644
index 0000000000..72c374cfd1
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayAtomicSimple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayAtomicSimple } from "../../structures/ArrayAtomicSimple";
+
+export const test_notation_createValidateKebab_ArrayAtomicSimple = (): void =>
+  _test_notation_validateGeneral("ArrayAtomicSimple")<ArrayAtomicSimple>(
+    ArrayAtomicSimple,
+  )<typia.KebabCase<ArrayAtomicSimple>>({
+    convert: typia.notations.createValidateKebab<ArrayAtomicSimple>(),
+    assert: typia.createAssert<typia.KebabCase<ArrayAtomicSimple>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayHierarchical.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayHierarchical.ts
new file mode 100644
index 0000000000..4f8e315b9c
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayHierarchical.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayHierarchical } from "../../structures/ArrayHierarchical";
+
+export const test_notation_createValidateKebab_ArrayHierarchical = (): void =>
+  _test_notation_validateGeneral("ArrayHierarchical")<ArrayHierarchical>(
+    ArrayHierarchical,
+  )<typia.KebabCase<ArrayHierarchical>>({
+    convert: typia.notations.createValidateKebab<ArrayHierarchical>(),
+    assert: typia.createAssert<typia.KebabCase<ArrayHierarchical>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayHierarchicalPointer.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayHierarchicalPointer.ts
new file mode 100644
index 0000000000..74d4b6ba7c
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayHierarchicalPointer.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayHierarchicalPointer } from "../../structures/ArrayHierarchicalPointer";
+
+export const test_notation_createValidateKebab_ArrayHierarchicalPointer =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArrayHierarchicalPointer",
+    )<ArrayHierarchicalPointer>(ArrayHierarchicalPointer)<
+      typia.KebabCase<ArrayHierarchicalPointer>
+    >({
+      convert: typia.notations.createValidateKebab<ArrayHierarchicalPointer>(),
+      assert: typia.createAssert<typia.KebabCase<ArrayHierarchicalPointer>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayMatrix.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayMatrix.ts
new file mode 100644
index 0000000000..ac1f1a1d27
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayMatrix.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayMatrix } from "../../structures/ArrayMatrix";
+
+export const test_notation_createValidateKebab_ArrayMatrix = (): void =>
+  _test_notation_validateGeneral("ArrayMatrix")<ArrayMatrix>(ArrayMatrix)<
+    typia.KebabCase<ArrayMatrix>
+  >({
+    convert: typia.notations.createValidateKebab<ArrayMatrix>(),
+    assert: typia.createAssert<typia.KebabCase<ArrayMatrix>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursive.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursive.ts
new file mode 100644
index 0000000000..c8a7a8b7a1
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursive.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRecursive } from "../../structures/ArrayRecursive";
+
+export const test_notation_createValidateKebab_ArrayRecursive = (): void =>
+  _test_notation_validateGeneral("ArrayRecursive")<ArrayRecursive>(
+    ArrayRecursive,
+  )<typia.KebabCase<ArrayRecursive>>({
+    convert: typia.notations.createValidateKebab<ArrayRecursive>(),
+    assert: typia.createAssert<typia.KebabCase<ArrayRecursive>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionExplicit.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionExplicit.ts
new file mode 100644
index 0000000000..5fc412c931
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionExplicit.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRecursiveUnionExplicit } from "../../structures/ArrayRecursiveUnionExplicit";
+
+export const test_notation_createValidateKebab_ArrayRecursiveUnionExplicit =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArrayRecursiveUnionExplicit",
+    )<ArrayRecursiveUnionExplicit>(ArrayRecursiveUnionExplicit)<
+      typia.KebabCase<ArrayRecursiveUnionExplicit>
+    >({
+      convert:
+        typia.notations.createValidateKebab<ArrayRecursiveUnionExplicit>(),
+      assert:
+        typia.createAssert<typia.KebabCase<ArrayRecursiveUnionExplicit>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionExplicitPointer.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionExplicitPointer.ts
new file mode 100644
index 0000000000..630e2623df
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionExplicitPointer.ts
@@ -0,0 +1,19 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRecursiveUnionExplicitPointer } from "../../structures/ArrayRecursiveUnionExplicitPointer";
+
+export const test_notation_createValidateKebab_ArrayRecursiveUnionExplicitPointer =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArrayRecursiveUnionExplicitPointer",
+    )<ArrayRecursiveUnionExplicitPointer>(ArrayRecursiveUnionExplicitPointer)<
+      typia.KebabCase<ArrayRecursiveUnionExplicitPointer>
+    >({
+      convert:
+        typia.notations.createValidateKebab<ArrayRecursiveUnionExplicitPointer>(),
+      assert:
+        typia.createAssert<
+          typia.KebabCase<ArrayRecursiveUnionExplicitPointer>
+        >(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionImplicit.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionImplicit.ts
new file mode 100644
index 0000000000..7826aedcf3
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRecursiveUnionImplicit.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRecursiveUnionImplicit } from "../../structures/ArrayRecursiveUnionImplicit";
+
+export const test_notation_createValidateKebab_ArrayRecursiveUnionImplicit =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArrayRecursiveUnionImplicit",
+    )<ArrayRecursiveUnionImplicit>(ArrayRecursiveUnionImplicit)<
+      typia.KebabCase<ArrayRecursiveUnionImplicit>
+    >({
+      convert:
+        typia.notations.createValidateKebab<ArrayRecursiveUnionImplicit>(),
+      assert:
+        typia.createAssert<typia.KebabCase<ArrayRecursiveUnionImplicit>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedNullable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedNullable.ts
new file mode 100644
index 0000000000..0255521c5a
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedNullable.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRepeatedNullable } from "../../structures/ArrayRepeatedNullable";
+
+export const test_notation_createValidateKebab_ArrayRepeatedNullable =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArrayRepeatedNullable",
+    )<ArrayRepeatedNullable>(ArrayRepeatedNullable)<
+      typia.KebabCase<ArrayRepeatedNullable>
+    >({
+      convert: typia.notations.createValidateKebab<ArrayRepeatedNullable>(),
+      assert: typia.createAssert<typia.KebabCase<ArrayRepeatedNullable>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedOptional.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedOptional.ts
new file mode 100644
index 0000000000..6b05e92320
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedOptional.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRepeatedOptional } from "../../structures/ArrayRepeatedOptional";
+
+export const test_notation_createValidateKebab_ArrayRepeatedOptional =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArrayRepeatedOptional",
+    )<ArrayRepeatedOptional>(ArrayRepeatedOptional)<
+      typia.KebabCase<ArrayRepeatedOptional>
+    >({
+      convert: typia.notations.createValidateKebab<ArrayRepeatedOptional>(),
+      assert: typia.createAssert<typia.KebabCase<ArrayRepeatedOptional>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedRequired.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedRequired.ts
new file mode 100644
index 0000000000..a60332bf90
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedRequired.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRepeatedRequired } from "../../structures/ArrayRepeatedRequired";
+
+export const test_notation_createValidateKebab_ArrayRepeatedRequired =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArrayRepeatedRequired",
+    )<ArrayRepeatedRequired>(ArrayRepeatedRequired)<
+      typia.KebabCase<ArrayRepeatedRequired>
+    >({
+      convert: typia.notations.createValidateKebab<ArrayRepeatedRequired>(),
+      assert: typia.createAssert<typia.KebabCase<ArrayRepeatedRequired>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedUnion.ts
new file mode 100644
index 0000000000..d1981d7bdb
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRepeatedUnion } from "../../structures/ArrayRepeatedUnion";
+
+export const test_notation_createValidateKebab_ArrayRepeatedUnion = (): void =>
+  _test_notation_validateGeneral("ArrayRepeatedUnion")<ArrayRepeatedUnion>(
+    ArrayRepeatedUnion,
+  )<typia.KebabCase<ArrayRepeatedUnion>>({
+    convert: typia.notations.createValidateKebab<ArrayRepeatedUnion>(),
+    assert: typia.createAssert<typia.KebabCase<ArrayRepeatedUnion>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedUnionWithTuple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedUnionWithTuple.ts
new file mode 100644
index 0000000000..1c4f7f525c
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayRepeatedUnionWithTuple.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRepeatedUnionWithTuple } from "../../structures/ArrayRepeatedUnionWithTuple";
+
+export const test_notation_createValidateKebab_ArrayRepeatedUnionWithTuple =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArrayRepeatedUnionWithTuple",
+    )<ArrayRepeatedUnionWithTuple>(ArrayRepeatedUnionWithTuple)<
+      typia.KebabCase<ArrayRepeatedUnionWithTuple>
+    >({
+      convert:
+        typia.notations.createValidateKebab<ArrayRepeatedUnionWithTuple>(),
+      assert:
+        typia.createAssert<typia.KebabCase<ArrayRepeatedUnionWithTuple>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimple.ts
new file mode 100644
index 0000000000..52b3a3b5ed
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArraySimple } from "../../structures/ArraySimple";
+
+export const test_notation_createValidateKebab_ArraySimple = (): void =>
+  _test_notation_validateGeneral("ArraySimple")<ArraySimple>(ArraySimple)<
+    typia.KebabCase<ArraySimple>
+  >({
+    convert: typia.notations.createValidateKebab<ArraySimple>(),
+    assert: typia.createAssert<typia.KebabCase<ArraySimple>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobuf.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobuf.ts
new file mode 100644
index 0000000000..bcd9f2a3e7
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobuf.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArraySimpleProtobuf } from "../../structures/ArraySimpleProtobuf";
+
+export const test_notation_createValidateKebab_ArraySimpleProtobuf = (): void =>
+  _test_notation_validateGeneral("ArraySimpleProtobuf")<ArraySimpleProtobuf>(
+    ArraySimpleProtobuf,
+  )<typia.KebabCase<ArraySimpleProtobuf>>({
+    convert: typia.notations.createValidateKebab<ArraySimpleProtobuf>(),
+    assert: typia.createAssert<typia.KebabCase<ArraySimpleProtobuf>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobufNullable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobufNullable.ts
new file mode 100644
index 0000000000..e9a51224b7
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobufNullable.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArraySimpleProtobufNullable } from "../../structures/ArraySimpleProtobufNullable";
+
+export const test_notation_createValidateKebab_ArraySimpleProtobufNullable =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArraySimpleProtobufNullable",
+    )<ArraySimpleProtobufNullable>(ArraySimpleProtobufNullable)<
+      typia.KebabCase<ArraySimpleProtobufNullable>
+    >({
+      convert:
+        typia.notations.createValidateKebab<ArraySimpleProtobufNullable>(),
+      assert:
+        typia.createAssert<typia.KebabCase<ArraySimpleProtobufNullable>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobufOptional.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobufOptional.ts
new file mode 100644
index 0000000000..73607829f1
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArraySimpleProtobufOptional.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArraySimpleProtobufOptional } from "../../structures/ArraySimpleProtobufOptional";
+
+export const test_notation_createValidateKebab_ArraySimpleProtobufOptional =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArraySimpleProtobufOptional",
+    )<ArraySimpleProtobufOptional>(ArraySimpleProtobufOptional)<
+      typia.KebabCase<ArraySimpleProtobufOptional>
+    >({
+      convert:
+        typia.notations.createValidateKebab<ArraySimpleProtobufOptional>(),
+      assert:
+        typia.createAssert<typia.KebabCase<ArraySimpleProtobufOptional>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ArrayUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayUnion.ts
new file mode 100644
index 0000000000..8d6c4e9a7a
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ArrayUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayUnion } from "../../structures/ArrayUnion";
+
+export const test_notation_createValidateKebab_ArrayUnion = (): void =>
+  _test_notation_validateGeneral("ArrayUnion")<ArrayUnion>(ArrayUnion)<
+    typia.KebabCase<ArrayUnion>
+  >({
+    convert: typia.notations.createValidateKebab<ArrayUnion>(),
+    assert: typia.createAssert<typia.KebabCase<ArrayUnion>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_AtomicAlias.ts b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicAlias.ts
new file mode 100644
index 0000000000..b64cbbb0d9
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicAlias.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { AtomicAlias } from "../../structures/AtomicAlias";
+
+export const test_notation_createValidateKebab_AtomicAlias = (): void =>
+  _test_notation_validateGeneral("AtomicAlias")<AtomicAlias>(AtomicAlias)<
+    typia.KebabCase<AtomicAlias>
+  >({
+    convert: typia.notations.createValidateKebab<AtomicAlias>(),
+    assert: typia.createAssert<typia.KebabCase<AtomicAlias>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_AtomicClass.ts b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicClass.ts
new file mode 100644
index 0000000000..014bfb3a6e
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicClass.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { AtomicClass } from "../../structures/AtomicClass";
+
+export const test_notation_createValidateKebab_AtomicClass = (): void =>
+  _test_notation_validateGeneral("AtomicClass")<AtomicClass>(AtomicClass)<
+    typia.KebabCase<AtomicClass>
+  >({
+    convert: typia.notations.createValidateKebab<AtomicClass>(),
+    assert: typia.createAssert<typia.KebabCase<AtomicClass>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_AtomicIntersection.ts b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicIntersection.ts
new file mode 100644
index 0000000000..896ae41d29
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicIntersection.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { AtomicIntersection } from "../../structures/AtomicIntersection";
+
+export const test_notation_createValidateKebab_AtomicIntersection = (): void =>
+  _test_notation_validateGeneral("AtomicIntersection")<AtomicIntersection>(
+    AtomicIntersection,
+  )<typia.KebabCase<AtomicIntersection>>({
+    convert: typia.notations.createValidateKebab<AtomicIntersection>(),
+    assert: typia.createAssert<typia.KebabCase<AtomicIntersection>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_AtomicSimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicSimple.ts
new file mode 100644
index 0000000000..763a39e9c4
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicSimple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { AtomicSimple } from "../../structures/AtomicSimple";
+
+export const test_notation_createValidateKebab_AtomicSimple = (): void =>
+  _test_notation_validateGeneral("AtomicSimple")<AtomicSimple>(AtomicSimple)<
+    typia.KebabCase<AtomicSimple>
+  >({
+    convert: typia.notations.createValidateKebab<AtomicSimple>(),
+    assert: typia.createAssert<typia.KebabCase<AtomicSimple>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_AtomicUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicUnion.ts
new file mode 100644
index 0000000000..a7b8b3cbcf
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_AtomicUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { AtomicUnion } from "../../structures/AtomicUnion";
+
+export const test_notation_createValidateKebab_AtomicUnion = (): void =>
+  _test_notation_validateGeneral("AtomicUnion")<AtomicUnion>(AtomicUnion)<
+    typia.KebabCase<AtomicUnion>
+  >({
+    convert: typia.notations.createValidateKebab<AtomicUnion>(),
+    assert: typia.createAssert<typia.KebabCase<AtomicUnion>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ClassMethod.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ClassMethod.ts
new file mode 100644
index 0000000000..f5ea855ff2
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ClassMethod.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ClassMethod } from "../../structures/ClassMethod";
+
+export const test_notation_createValidateKebab_ClassMethod = (): void =>
+  _test_notation_validateGeneral("ClassMethod")<ClassMethod>(ClassMethod)<
+    typia.KebabCase<ClassMethod>
+  >({
+    convert: typia.notations.createValidateKebab<ClassMethod>(),
+    assert: typia.createAssert<typia.KebabCase<ClassMethod>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ClassNonPublic.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ClassNonPublic.ts
new file mode 100644
index 0000000000..8eddb6b74b
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ClassNonPublic.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ClassNonPublic } from "../../structures/ClassNonPublic";
+
+export const test_notation_createValidateKebab_ClassNonPublic = (): void =>
+  _test_notation_validateGeneral("ClassNonPublic")<ClassNonPublic>(
+    ClassNonPublic,
+  )<typia.KebabCase<ClassNonPublic>>({
+    convert: typia.notations.createValidateKebab<ClassNonPublic>(),
+    assert: typia.createAssert<typia.KebabCase<ClassNonPublic>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ClassPropertyAssignment.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ClassPropertyAssignment.ts
new file mode 100644
index 0000000000..0b3d5c5b49
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ClassPropertyAssignment.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ClassPropertyAssignment } from "../../structures/ClassPropertyAssignment";
+
+export const test_notation_createValidateKebab_ClassPropertyAssignment =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ClassPropertyAssignment",
+    )<ClassPropertyAssignment>(ClassPropertyAssignment)<
+      typia.KebabCase<ClassPropertyAssignment>
+    >({
+      convert: typia.notations.createValidateKebab<ClassPropertyAssignment>(),
+      assert: typia.createAssert<typia.KebabCase<ClassPropertyAssignment>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagArray.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagArray.ts
new file mode 100644
index 0000000000..98575a30d5
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagArray.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagArray } from "../../structures/CommentTagArray";
+
+export const test_notation_createValidateKebab_CommentTagArray = (): void =>
+  _test_notation_validateGeneral("CommentTagArray")<CommentTagArray>(
+    CommentTagArray,
+  )<typia.KebabCase<CommentTagArray>>({
+    convert: typia.notations.createValidateKebab<CommentTagArray>(),
+    assert: typia.createAssert<typia.KebabCase<CommentTagArray>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagArrayUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagArrayUnion.ts
new file mode 100644
index 0000000000..03b2f3913a
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagArrayUnion.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagArrayUnion } from "../../structures/CommentTagArrayUnion";
+
+export const test_notation_createValidateKebab_CommentTagArrayUnion =
+  (): void =>
+    _test_notation_validateGeneral(
+      "CommentTagArrayUnion",
+    )<CommentTagArrayUnion>(CommentTagArrayUnion)<
+      typia.KebabCase<CommentTagArrayUnion>
+    >({
+      convert: typia.notations.createValidateKebab<CommentTagArrayUnion>(),
+      assert: typia.createAssert<typia.KebabCase<CommentTagArrayUnion>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagAtomicUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagAtomicUnion.ts
new file mode 100644
index 0000000000..c4e63d2efa
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagAtomicUnion.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagAtomicUnion } from "../../structures/CommentTagAtomicUnion";
+
+export const test_notation_createValidateKebab_CommentTagAtomicUnion =
+  (): void =>
+    _test_notation_validateGeneral(
+      "CommentTagAtomicUnion",
+    )<CommentTagAtomicUnion>(CommentTagAtomicUnion)<
+      typia.KebabCase<CommentTagAtomicUnion>
+    >({
+      convert: typia.notations.createValidateKebab<CommentTagAtomicUnion>(),
+      assert: typia.createAssert<typia.KebabCase<CommentTagAtomicUnion>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagBigInt.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagBigInt.ts
new file mode 100644
index 0000000000..f3540ea948
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagBigInt.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagBigInt } from "../../structures/CommentTagBigInt";
+
+export const test_notation_createValidateKebab_CommentTagBigInt = (): void =>
+  _test_notation_validateGeneral("CommentTagBigInt")<CommentTagBigInt>(
+    CommentTagBigInt,
+  )<typia.KebabCase<CommentTagBigInt>>({
+    convert: typia.notations.createValidateKebab<CommentTagBigInt>(),
+    assert: typia.createAssert<typia.KebabCase<CommentTagBigInt>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagDefault.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagDefault.ts
new file mode 100644
index 0000000000..9195585dee
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagDefault.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagDefault } from "../../structures/CommentTagDefault";
+
+export const test_notation_createValidateKebab_CommentTagDefault = (): void =>
+  _test_notation_validateGeneral("CommentTagDefault")<CommentTagDefault>(
+    CommentTagDefault,
+  )<typia.KebabCase<CommentTagDefault>>({
+    convert: typia.notations.createValidateKebab<CommentTagDefault>(),
+    assert: typia.createAssert<typia.KebabCase<CommentTagDefault>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagFormat.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagFormat.ts
new file mode 100644
index 0000000000..f532def4a3
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagFormat.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagFormat } from "../../structures/CommentTagFormat";
+
+export const test_notation_createValidateKebab_CommentTagFormat = (): void =>
+  _test_notation_validateGeneral("CommentTagFormat")<CommentTagFormat>(
+    CommentTagFormat,
+  )<typia.KebabCase<CommentTagFormat>>({
+    convert: typia.notations.createValidateKebab<CommentTagFormat>(),
+    assert: typia.createAssert<typia.KebabCase<CommentTagFormat>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagInfinite.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagInfinite.ts
new file mode 100644
index 0000000000..71732180e5
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagInfinite.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagInfinite } from "../../structures/CommentTagInfinite";
+
+export const test_notation_createValidateKebab_CommentTagInfinite = (): void =>
+  _test_notation_validateGeneral("CommentTagInfinite")<CommentTagInfinite>(
+    CommentTagInfinite,
+  )<typia.KebabCase<CommentTagInfinite>>({
+    convert: typia.notations.createValidateKebab<CommentTagInfinite>(),
+    assert: typia.createAssert<typia.KebabCase<CommentTagInfinite>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagLength.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagLength.ts
new file mode 100644
index 0000000000..1c94a35b86
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagLength.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagLength } from "../../structures/CommentTagLength";
+
+export const test_notation_createValidateKebab_CommentTagLength = (): void =>
+  _test_notation_validateGeneral("CommentTagLength")<CommentTagLength>(
+    CommentTagLength,
+  )<typia.KebabCase<CommentTagLength>>({
+    convert: typia.notations.createValidateKebab<CommentTagLength>(),
+    assert: typia.createAssert<typia.KebabCase<CommentTagLength>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagNaN.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagNaN.ts
new file mode 100644
index 0000000000..205195a438
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagNaN.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagNaN } from "../../structures/CommentTagNaN";
+
+export const test_notation_createValidateKebab_CommentTagNaN = (): void =>
+  _test_notation_validateGeneral("CommentTagNaN")<CommentTagNaN>(CommentTagNaN)<
+    typia.KebabCase<CommentTagNaN>
+  >({
+    convert: typia.notations.createValidateKebab<CommentTagNaN>(),
+    assert: typia.createAssert<typia.KebabCase<CommentTagNaN>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagObjectUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagObjectUnion.ts
new file mode 100644
index 0000000000..abacd78c44
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagObjectUnion.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagObjectUnion } from "../../structures/CommentTagObjectUnion";
+
+export const test_notation_createValidateKebab_CommentTagObjectUnion =
+  (): void =>
+    _test_notation_validateGeneral(
+      "CommentTagObjectUnion",
+    )<CommentTagObjectUnion>(CommentTagObjectUnion)<
+      typia.KebabCase<CommentTagObjectUnion>
+    >({
+      convert: typia.notations.createValidateKebab<CommentTagObjectUnion>(),
+      assert: typia.createAssert<typia.KebabCase<CommentTagObjectUnion>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagPattern.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagPattern.ts
new file mode 100644
index 0000000000..eaf4759801
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagPattern.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagPattern } from "../../structures/CommentTagPattern";
+
+export const test_notation_createValidateKebab_CommentTagPattern = (): void =>
+  _test_notation_validateGeneral("CommentTagPattern")<CommentTagPattern>(
+    CommentTagPattern,
+  )<typia.KebabCase<CommentTagPattern>>({
+    convert: typia.notations.createValidateKebab<CommentTagPattern>(),
+    assert: typia.createAssert<typia.KebabCase<CommentTagPattern>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagRange.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagRange.ts
new file mode 100644
index 0000000000..84e544579b
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagRange.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagRange } from "../../structures/CommentTagRange";
+
+export const test_notation_createValidateKebab_CommentTagRange = (): void =>
+  _test_notation_validateGeneral("CommentTagRange")<CommentTagRange>(
+    CommentTagRange,
+  )<typia.KebabCase<CommentTagRange>>({
+    convert: typia.notations.createValidateKebab<CommentTagRange>(),
+    assert: typia.createAssert<typia.KebabCase<CommentTagRange>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagRangeBigInt.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagRangeBigInt.ts
new file mode 100644
index 0000000000..c8e62b7a4a
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagRangeBigInt.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagRangeBigInt } from "../../structures/CommentTagRangeBigInt";
+
+export const test_notation_createValidateKebab_CommentTagRangeBigInt =
+  (): void =>
+    _test_notation_validateGeneral(
+      "CommentTagRangeBigInt",
+    )<CommentTagRangeBigInt>(CommentTagRangeBigInt)<
+      typia.KebabCase<CommentTagRangeBigInt>
+    >({
+      convert: typia.notations.createValidateKebab<CommentTagRangeBigInt>(),
+      assert: typia.createAssert<typia.KebabCase<CommentTagRangeBigInt>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagType.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagType.ts
new file mode 100644
index 0000000000..9fc664af99
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagType.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagType } from "../../structures/CommentTagType";
+
+export const test_notation_createValidateKebab_CommentTagType = (): void =>
+  _test_notation_validateGeneral("CommentTagType")<CommentTagType>(
+    CommentTagType,
+  )<typia.KebabCase<CommentTagType>>({
+    convert: typia.notations.createValidateKebab<CommentTagType>(),
+    assert: typia.createAssert<typia.KebabCase<CommentTagType>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagTypeBigInt.ts b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagTypeBigInt.ts
new file mode 100644
index 0000000000..9687e99f15
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_CommentTagTypeBigInt.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagTypeBigInt } from "../../structures/CommentTagTypeBigInt";
+
+export const test_notation_createValidateKebab_CommentTagTypeBigInt =
+  (): void =>
+    _test_notation_validateGeneral(
+      "CommentTagTypeBigInt",
+    )<CommentTagTypeBigInt>(CommentTagTypeBigInt)<
+      typia.KebabCase<CommentTagTypeBigInt>
+    >({
+      convert: typia.notations.createValidateKebab<CommentTagTypeBigInt>(),
+      assert: typia.createAssert<typia.KebabCase<CommentTagTypeBigInt>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicAbsorbed.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicAbsorbed.ts
new file mode 100644
index 0000000000..5521b03269
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicAbsorbed.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantAtomicAbsorbed } from "../../structures/ConstantAtomicAbsorbed";
+
+export const test_notation_createValidateKebab_ConstantAtomicAbsorbed =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ConstantAtomicAbsorbed",
+    )<ConstantAtomicAbsorbed>(ConstantAtomicAbsorbed)<
+      typia.KebabCase<ConstantAtomicAbsorbed>
+    >({
+      convert: typia.notations.createValidateKebab<ConstantAtomicAbsorbed>(),
+      assert: typia.createAssert<typia.KebabCase<ConstantAtomicAbsorbed>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicSimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicSimple.ts
new file mode 100644
index 0000000000..e35b07869a
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicSimple.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantAtomicSimple } from "../../structures/ConstantAtomicSimple";
+
+export const test_notation_createValidateKebab_ConstantAtomicSimple =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ConstantAtomicSimple",
+    )<ConstantAtomicSimple>(ConstantAtomicSimple)<
+      typia.KebabCase<ConstantAtomicSimple>
+    >({
+      convert: typia.notations.createValidateKebab<ConstantAtomicSimple>(),
+      assert: typia.createAssert<typia.KebabCase<ConstantAtomicSimple>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicTagged.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicTagged.ts
new file mode 100644
index 0000000000..ccff60a336
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicTagged.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantAtomicTagged } from "../../structures/ConstantAtomicTagged";
+
+export const test_notation_createValidateKebab_ConstantAtomicTagged =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ConstantAtomicTagged",
+    )<ConstantAtomicTagged>(ConstantAtomicTagged)<
+      typia.KebabCase<ConstantAtomicTagged>
+    >({
+      convert: typia.notations.createValidateKebab<ConstantAtomicTagged>(),
+      assert: typia.createAssert<typia.KebabCase<ConstantAtomicTagged>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicUnion.ts
new file mode 100644
index 0000000000..57c7c5557d
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantAtomicUnion } from "../../structures/ConstantAtomicUnion";
+
+export const test_notation_createValidateKebab_ConstantAtomicUnion = (): void =>
+  _test_notation_validateGeneral("ConstantAtomicUnion")<ConstantAtomicUnion>(
+    ConstantAtomicUnion,
+  )<typia.KebabCase<ConstantAtomicUnion>>({
+    convert: typia.notations.createValidateKebab<ConstantAtomicUnion>(),
+    assert: typia.createAssert<typia.KebabCase<ConstantAtomicUnion>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicWrapper.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicWrapper.ts
new file mode 100644
index 0000000000..0cef32d018
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantAtomicWrapper.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantAtomicWrapper } from "../../structures/ConstantAtomicWrapper";
+
+export const test_notation_createValidateKebab_ConstantAtomicWrapper =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ConstantAtomicWrapper",
+    )<ConstantAtomicWrapper>(ConstantAtomicWrapper)<
+      typia.KebabCase<ConstantAtomicWrapper>
+    >({
+      convert: typia.notations.createValidateKebab<ConstantAtomicWrapper>(),
+      assert: typia.createAssert<typia.KebabCase<ConstantAtomicWrapper>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantConstEnumeration.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantConstEnumeration.ts
new file mode 100644
index 0000000000..290c390bfe
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantConstEnumeration.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantConstEnumeration } from "../../structures/ConstantConstEnumeration";
+
+export const test_notation_createValidateKebab_ConstantConstEnumeration =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ConstantConstEnumeration",
+    )<ConstantConstEnumeration>(ConstantConstEnumeration)<
+      typia.KebabCase<ConstantConstEnumeration>
+    >({
+      convert: typia.notations.createValidateKebab<ConstantConstEnumeration>(),
+      assert: typia.createAssert<typia.KebabCase<ConstantConstEnumeration>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantEnumeration.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantEnumeration.ts
new file mode 100644
index 0000000000..6bcd1853a6
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantEnumeration.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantEnumeration } from "../../structures/ConstantEnumeration";
+
+export const test_notation_createValidateKebab_ConstantEnumeration = (): void =>
+  _test_notation_validateGeneral("ConstantEnumeration")<ConstantEnumeration>(
+    ConstantEnumeration,
+  )<typia.KebabCase<ConstantEnumeration>>({
+    convert: typia.notations.createValidateKebab<ConstantEnumeration>(),
+    assert: typia.createAssert<typia.KebabCase<ConstantEnumeration>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ConstantIntersection.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantIntersection.ts
new file mode 100644
index 0000000000..2aba18073b
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ConstantIntersection.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantIntersection } from "../../structures/ConstantIntersection";
+
+export const test_notation_createValidateKebab_ConstantIntersection =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ConstantIntersection",
+    )<ConstantIntersection>(ConstantIntersection)<
+      typia.KebabCase<ConstantIntersection>
+    >({
+      convert: typia.notations.createValidateKebab<ConstantIntersection>(),
+      assert: typia.createAssert<typia.KebabCase<ConstantIntersection>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_InstanceUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_InstanceUnion.ts
new file mode 100644
index 0000000000..807458d7b2
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_InstanceUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { InstanceUnion } from "../../structures/InstanceUnion";
+
+export const test_notation_createValidateKebab_InstanceUnion = (): void =>
+  _test_notation_validateGeneral("InstanceUnion")<InstanceUnion>(InstanceUnion)<
+    typia.KebabCase<InstanceUnion>
+  >({
+    convert: typia.notations.createValidateKebab<InstanceUnion>(),
+    assert: typia.createAssert<typia.KebabCase<InstanceUnion>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_MapAlias.ts b/test/src/features/notation.createKebab/test_notation_createKebab_MapAlias.ts
new file mode 100644
index 0000000000..fbf9035152
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_MapAlias.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { MapAlias } from "../../structures/MapAlias";
+
+export const test_notation_createValidateKebab_MapAlias = (): void =>
+  _test_notation_validateGeneral("MapAlias")<MapAlias>(MapAlias)<
+    typia.KebabCase<MapAlias>
+  >({
+    convert: typia.notations.createValidateKebab<MapAlias>(),
+    assert: typia.createAssert<typia.KebabCase<MapAlias>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_MapSimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimple.ts
new file mode 100644
index 0000000000..5ffaa8cdc1
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { MapSimple } from "../../structures/MapSimple";
+
+export const test_notation_createValidateKebab_MapSimple = (): void =>
+  _test_notation_validateGeneral("MapSimple")<MapSimple>(MapSimple)<
+    typia.KebabCase<MapSimple>
+  >({
+    convert: typia.notations.createValidateKebab<MapSimple>(),
+    assert: typia.createAssert<typia.KebabCase<MapSimple>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobuf.ts b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobuf.ts
new file mode 100644
index 0000000000..dfb1828a2e
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobuf.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { MapSimpleProtobuf } from "../../structures/MapSimpleProtobuf";
+
+export const test_notation_createValidateKebab_MapSimpleProtobuf = (): void =>
+  _test_notation_validateGeneral("MapSimpleProtobuf")<MapSimpleProtobuf>(
+    MapSimpleProtobuf,
+  )<typia.KebabCase<MapSimpleProtobuf>>({
+    convert: typia.notations.createValidateKebab<MapSimpleProtobuf>(),
+    assert: typia.createAssert<typia.KebabCase<MapSimpleProtobuf>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobufNullable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobufNullable.ts
new file mode 100644
index 0000000000..b98228ee8d
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobufNullable.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { MapSimpleProtobufNullable } from "../../structures/MapSimpleProtobufNullable";
+
+export const test_notation_createValidateKebab_MapSimpleProtobufNullable =
+  (): void =>
+    _test_notation_validateGeneral(
+      "MapSimpleProtobufNullable",
+    )<MapSimpleProtobufNullable>(MapSimpleProtobufNullable)<
+      typia.KebabCase<MapSimpleProtobufNullable>
+    >({
+      convert: typia.notations.createValidateKebab<MapSimpleProtobufNullable>(),
+      assert: typia.createAssert<typia.KebabCase<MapSimpleProtobufNullable>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobufOptional.ts b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobufOptional.ts
new file mode 100644
index 0000000000..0f2b155c19
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_MapSimpleProtobufOptional.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { MapSimpleProtobufOptional } from "../../structures/MapSimpleProtobufOptional";
+
+export const test_notation_createValidateKebab_MapSimpleProtobufOptional =
+  (): void =>
+    _test_notation_validateGeneral(
+      "MapSimpleProtobufOptional",
+    )<MapSimpleProtobufOptional>(MapSimpleProtobufOptional)<
+      typia.KebabCase<MapSimpleProtobufOptional>
+    >({
+      convert: typia.notations.createValidateKebab<MapSimpleProtobufOptional>(),
+      assert: typia.createAssert<typia.KebabCase<MapSimpleProtobufOptional>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_MapUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_MapUnion.ts
new file mode 100644
index 0000000000..c93bb47921
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_MapUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { MapUnion } from "../../structures/MapUnion";
+
+export const test_notation_createValidateKebab_MapUnion = (): void =>
+  _test_notation_validateGeneral("MapUnion")<MapUnion>(MapUnion)<
+    typia.KebabCase<MapUnion>
+  >({
+    convert: typia.notations.createValidateKebab<MapUnion>(),
+    assert: typia.createAssert<typia.KebabCase<MapUnion>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_NativeSimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_NativeSimple.ts
new file mode 100644
index 0000000000..33ab0a56a3
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_NativeSimple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { NativeSimple } from "../../structures/NativeSimple";
+
+export const test_notation_createValidateKebab_NativeSimple = (): void =>
+  _test_notation_validateGeneral("NativeSimple")<NativeSimple>(NativeSimple)<
+    typia.KebabCase<NativeSimple>
+  >({
+    convert: typia.notations.createValidateKebab<NativeSimple>(),
+    assert: typia.createAssert<typia.KebabCase<NativeSimple>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_NativeUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_NativeUnion.ts
new file mode 100644
index 0000000000..4cf8b3e634
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_NativeUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { NativeUnion } from "../../structures/NativeUnion";
+
+export const test_notation_createValidateKebab_NativeUnion = (): void =>
+  _test_notation_validateGeneral("NativeUnion")<NativeUnion>(NativeUnion)<
+    typia.KebabCase<NativeUnion>
+  >({
+    convert: typia.notations.createValidateKebab<NativeUnion>(),
+    assert: typia.createAssert<typia.KebabCase<NativeUnion>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectAlias.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectAlias.ts
new file mode 100644
index 0000000000..4563b1192a
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectAlias.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectAlias } from "../../structures/ObjectAlias";
+
+export const test_notation_createValidateKebab_ObjectAlias = (): void =>
+  _test_notation_validateGeneral("ObjectAlias")<ObjectAlias>(ObjectAlias)<
+    typia.KebabCase<ObjectAlias>
+  >({
+    convert: typia.notations.createValidateKebab<ObjectAlias>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectAlias>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDate.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDate.ts
new file mode 100644
index 0000000000..eba173072c
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDate.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectDate } from "../../structures/ObjectDate";
+
+export const test_notation_createValidateKebab_ObjectDate = (): void =>
+  _test_notation_validateGeneral("ObjectDate")<ObjectDate>(ObjectDate)<
+    typia.KebabCase<ObjectDate>
+  >({
+    convert: typia.notations.createValidateKebab<ObjectDate>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectDate>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDescription.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDescription.ts
new file mode 100644
index 0000000000..bea1f71de4
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDescription.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectDescription } from "../../structures/ObjectDescription";
+
+export const test_notation_createValidateKebab_ObjectDescription = (): void =>
+  _test_notation_validateGeneral("ObjectDescription")<ObjectDescription>(
+    ObjectDescription,
+  )<typia.KebabCase<ObjectDescription>>({
+    convert: typia.notations.createValidateKebab<ObjectDescription>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectDescription>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDynamic.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDynamic.ts
new file mode 100644
index 0000000000..5c67f65f46
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectDynamic.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectDynamic } from "../../structures/ObjectDynamic";
+
+export const test_notation_createValidateKebab_ObjectDynamic = (): void =>
+  _test_notation_validateGeneral("ObjectDynamic")<ObjectDynamic>(ObjectDynamic)<
+    typia.KebabCase<ObjectDynamic>
+  >({
+    convert: typia.notations.createValidateKebab<ObjectDynamic>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectDynamic>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGeneric.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGeneric.ts
new file mode 100644
index 0000000000..40f27def33
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGeneric.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectGeneric } from "../../structures/ObjectGeneric";
+
+export const test_notation_createValidateKebab_ObjectGeneric = (): void =>
+  _test_notation_validateGeneral("ObjectGeneric")<ObjectGeneric>(ObjectGeneric)<
+    typia.KebabCase<ObjectGeneric>
+  >({
+    convert: typia.notations.createValidateKebab<ObjectGeneric>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectGeneric>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericAlias.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericAlias.ts
new file mode 100644
index 0000000000..aee6f832ce
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericAlias.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectGenericAlias } from "../../structures/ObjectGenericAlias";
+
+export const test_notation_createValidateKebab_ObjectGenericAlias = (): void =>
+  _test_notation_validateGeneral("ObjectGenericAlias")<ObjectGenericAlias>(
+    ObjectGenericAlias,
+  )<typia.KebabCase<ObjectGenericAlias>>({
+    convert: typia.notations.createValidateKebab<ObjectGenericAlias>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectGenericAlias>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericArray.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericArray.ts
new file mode 100644
index 0000000000..9732f250fe
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericArray.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectGenericArray } from "../../structures/ObjectGenericArray";
+
+export const test_notation_createValidateKebab_ObjectGenericArray = (): void =>
+  _test_notation_validateGeneral("ObjectGenericArray")<ObjectGenericArray>(
+    ObjectGenericArray,
+  )<typia.KebabCase<ObjectGenericArray>>({
+    convert: typia.notations.createValidateKebab<ObjectGenericArray>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectGenericArray>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericUnion.ts
new file mode 100644
index 0000000000..e401ea9b3e
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectGenericUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectGenericUnion } from "../../structures/ObjectGenericUnion";
+
+export const test_notation_createValidateKebab_ObjectGenericUnion = (): void =>
+  _test_notation_validateGeneral("ObjectGenericUnion")<ObjectGenericUnion>(
+    ObjectGenericUnion,
+  )<typia.KebabCase<ObjectGenericUnion>>({
+    convert: typia.notations.createValidateKebab<ObjectGenericUnion>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectGenericUnion>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHierarchical.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHierarchical.ts
new file mode 100644
index 0000000000..8588745ced
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHierarchical.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHierarchical } from "../../structures/ObjectHierarchical";
+
+export const test_notation_createValidateKebab_ObjectHierarchical = (): void =>
+  _test_notation_validateGeneral("ObjectHierarchical")<ObjectHierarchical>(
+    ObjectHierarchical,
+  )<typia.KebabCase<ObjectHierarchical>>({
+    convert: typia.notations.createValidateKebab<ObjectHierarchical>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectHierarchical>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpArray.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpArray.ts
new file mode 100644
index 0000000000..41b43fd7a6
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpArray.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpArray } from "../../structures/ObjectHttpArray";
+
+export const test_notation_createValidateKebab_ObjectHttpArray = (): void =>
+  _test_notation_validateGeneral("ObjectHttpArray")<ObjectHttpArray>(
+    ObjectHttpArray,
+  )<typia.KebabCase<ObjectHttpArray>>({
+    convert: typia.notations.createValidateKebab<ObjectHttpArray>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectHttpArray>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpAtomic.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpAtomic.ts
new file mode 100644
index 0000000000..a2ed85acbc
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpAtomic.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpAtomic } from "../../structures/ObjectHttpAtomic";
+
+export const test_notation_createValidateKebab_ObjectHttpAtomic = (): void =>
+  _test_notation_validateGeneral("ObjectHttpAtomic")<ObjectHttpAtomic>(
+    ObjectHttpAtomic,
+  )<typia.KebabCase<ObjectHttpAtomic>>({
+    convert: typia.notations.createValidateKebab<ObjectHttpAtomic>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectHttpAtomic>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpCommentTag.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpCommentTag.ts
new file mode 100644
index 0000000000..4a8c7d1cf8
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpCommentTag.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpCommentTag } from "../../structures/ObjectHttpCommentTag";
+
+export const test_notation_createValidateKebab_ObjectHttpCommentTag =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectHttpCommentTag",
+    )<ObjectHttpCommentTag>(ObjectHttpCommentTag)<
+      typia.KebabCase<ObjectHttpCommentTag>
+    >({
+      convert: typia.notations.createValidateKebab<ObjectHttpCommentTag>(),
+      assert: typia.createAssert<typia.KebabCase<ObjectHttpCommentTag>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpConstant.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpConstant.ts
new file mode 100644
index 0000000000..6a55d7c409
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpConstant.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpConstant } from "../../structures/ObjectHttpConstant";
+
+export const test_notation_createValidateKebab_ObjectHttpConstant = (): void =>
+  _test_notation_validateGeneral("ObjectHttpConstant")<ObjectHttpConstant>(
+    ObjectHttpConstant,
+  )<typia.KebabCase<ObjectHttpConstant>>({
+    convert: typia.notations.createValidateKebab<ObjectHttpConstant>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectHttpConstant>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpFormData.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpFormData.ts
new file mode 100644
index 0000000000..2cfb239964
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpFormData.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpFormData } from "../../structures/ObjectHttpFormData";
+
+export const test_notation_createValidateKebab_ObjectHttpFormData = (): void =>
+  _test_notation_validateGeneral("ObjectHttpFormData")<ObjectHttpFormData>(
+    ObjectHttpFormData,
+  )<typia.KebabCase<ObjectHttpFormData>>({
+    convert: typia.notations.createValidateKebab<ObjectHttpFormData>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectHttpFormData>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpNullable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpNullable.ts
new file mode 100644
index 0000000000..c26ba57c64
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpNullable.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpNullable } from "../../structures/ObjectHttpNullable";
+
+export const test_notation_createValidateKebab_ObjectHttpNullable = (): void =>
+  _test_notation_validateGeneral("ObjectHttpNullable")<ObjectHttpNullable>(
+    ObjectHttpNullable,
+  )<typia.KebabCase<ObjectHttpNullable>>({
+    convert: typia.notations.createValidateKebab<ObjectHttpNullable>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectHttpNullable>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpTypeTag.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpTypeTag.ts
new file mode 100644
index 0000000000..e28c48cf2d
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpTypeTag.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpTypeTag } from "../../structures/ObjectHttpTypeTag";
+
+export const test_notation_createValidateKebab_ObjectHttpTypeTag = (): void =>
+  _test_notation_validateGeneral("ObjectHttpTypeTag")<ObjectHttpTypeTag>(
+    ObjectHttpTypeTag,
+  )<typia.KebabCase<ObjectHttpTypeTag>>({
+    convert: typia.notations.createValidateKebab<ObjectHttpTypeTag>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectHttpTypeTag>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpUndefindable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpUndefindable.ts
new file mode 100644
index 0000000000..e6686abdca
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectHttpUndefindable.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpUndefindable } from "../../structures/ObjectHttpUndefindable";
+
+export const test_notation_createValidateKebab_ObjectHttpUndefindable =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectHttpUndefindable",
+    )<ObjectHttpUndefindable>(ObjectHttpUndefindable)<
+      typia.KebabCase<ObjectHttpUndefindable>
+    >({
+      convert: typia.notations.createValidateKebab<ObjectHttpUndefindable>(),
+      assert: typia.createAssert<typia.KebabCase<ObjectHttpUndefindable>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectIntersection.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectIntersection.ts
new file mode 100644
index 0000000000..dbf0ea027e
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectIntersection.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectIntersection } from "../../structures/ObjectIntersection";
+
+export const test_notation_createValidateKebab_ObjectIntersection = (): void =>
+  _test_notation_validateGeneral("ObjectIntersection")<ObjectIntersection>(
+    ObjectIntersection,
+  )<typia.KebabCase<ObjectIntersection>>({
+    convert: typia.notations.createValidateKebab<ObjectIntersection>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectIntersection>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectJsonTag.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectJsonTag.ts
new file mode 100644
index 0000000000..38983b3324
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectJsonTag.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectJsonTag } from "../../structures/ObjectJsonTag";
+
+export const test_notation_createValidateKebab_ObjectJsonTag = (): void =>
+  _test_notation_validateGeneral("ObjectJsonTag")<ObjectJsonTag>(ObjectJsonTag)<
+    typia.KebabCase<ObjectJsonTag>
+  >({
+    convert: typia.notations.createValidateKebab<ObjectJsonTag>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectJsonTag>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectLiteralProperty.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectLiteralProperty.ts
new file mode 100644
index 0000000000..687326511e
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectLiteralProperty.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectLiteralProperty } from "../../structures/ObjectLiteralProperty";
+
+export const test_notation_createValidateKebab_ObjectLiteralProperty =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectLiteralProperty",
+    )<ObjectLiteralProperty>(ObjectLiteralProperty)<
+      typia.KebabCase<ObjectLiteralProperty>
+    >({
+      convert: typia.notations.createValidateKebab<ObjectLiteralProperty>(),
+      assert: typia.createAssert<typia.KebabCase<ObjectLiteralProperty>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectLiteralType.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectLiteralType.ts
new file mode 100644
index 0000000000..4a1c4b0fed
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectLiteralType.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectLiteralType } from "../../structures/ObjectLiteralType";
+
+export const test_notation_createValidateKebab_ObjectLiteralType = (): void =>
+  _test_notation_validateGeneral("ObjectLiteralType")<ObjectLiteralType>(
+    ObjectLiteralType,
+  )<typia.KebabCase<ObjectLiteralType>>({
+    convert: typia.notations.createValidateKebab<ObjectLiteralType>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectLiteralType>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectNullable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectNullable.ts
new file mode 100644
index 0000000000..dde19e5cf6
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectNullable.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectNullable } from "../../structures/ObjectNullable";
+
+export const test_notation_createValidateKebab_ObjectNullable = (): void =>
+  _test_notation_validateGeneral("ObjectNullable")<ObjectNullable>(
+    ObjectNullable,
+  )<typia.KebabCase<ObjectNullable>>({
+    convert: typia.notations.createValidateKebab<ObjectNullable>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectNullable>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectOptional.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectOptional.ts
new file mode 100644
index 0000000000..9597f7c798
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectOptional.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectOptional } from "../../structures/ObjectOptional";
+
+export const test_notation_createValidateKebab_ObjectOptional = (): void =>
+  _test_notation_validateGeneral("ObjectOptional")<ObjectOptional>(
+    ObjectOptional,
+  )<typia.KebabCase<ObjectOptional>>({
+    convert: typia.notations.createValidateKebab<ObjectOptional>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectOptional>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPartial.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPartial.ts
new file mode 100644
index 0000000000..c494f683a7
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPartial.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectPartial } from "../../structures/ObjectPartial";
+
+export const test_notation_createValidateKebab_ObjectPartial = (): void =>
+  _test_notation_validateGeneral("ObjectPartial")<ObjectPartial>(ObjectPartial)<
+    typia.KebabCase<ObjectPartial>
+  >({
+    convert: typia.notations.createValidateKebab<ObjectPartial>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectPartial>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPartialAndRequired.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPartialAndRequired.ts
new file mode 100644
index 0000000000..6349355c93
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPartialAndRequired.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectPartialAndRequired } from "../../structures/ObjectPartialAndRequired";
+
+export const test_notation_createValidateKebab_ObjectPartialAndRequired =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectPartialAndRequired",
+    )<ObjectPartialAndRequired>(ObjectPartialAndRequired)<
+      typia.KebabCase<ObjectPartialAndRequired>
+    >({
+      convert: typia.notations.createValidateKebab<ObjectPartialAndRequired>(),
+      assert: typia.createAssert<typia.KebabCase<ObjectPartialAndRequired>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPrimitive.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPrimitive.ts
new file mode 100644
index 0000000000..d9fe8a49ce
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPrimitive.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectPrimitive } from "../../structures/ObjectPrimitive";
+
+export const test_notation_createValidateKebab_ObjectPrimitive = (): void =>
+  _test_notation_validateGeneral("ObjectPrimitive")<ObjectPrimitive>(
+    ObjectPrimitive,
+  )<typia.KebabCase<ObjectPrimitive>>({
+    convert: typia.notations.createValidateKebab<ObjectPrimitive>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectPrimitive>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPropertyNullable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPropertyNullable.ts
new file mode 100644
index 0000000000..5747774cd0
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectPropertyNullable.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectPropertyNullable } from "../../structures/ObjectPropertyNullable";
+
+export const test_notation_createValidateKebab_ObjectPropertyNullable =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectPropertyNullable",
+    )<ObjectPropertyNullable>(ObjectPropertyNullable)<
+      typia.KebabCase<ObjectPropertyNullable>
+    >({
+      convert: typia.notations.createValidateKebab<ObjectPropertyNullable>(),
+      assert: typia.createAssert<typia.KebabCase<ObjectPropertyNullable>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectRecursive.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectRecursive.ts
new file mode 100644
index 0000000000..420b51b35c
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectRecursive.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectRecursive } from "../../structures/ObjectRecursive";
+
+export const test_notation_createValidateKebab_ObjectRecursive = (): void =>
+  _test_notation_validateGeneral("ObjectRecursive")<ObjectRecursive>(
+    ObjectRecursive,
+  )<typia.KebabCase<ObjectRecursive>>({
+    convert: typia.notations.createValidateKebab<ObjectRecursive>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectRecursive>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectRequired.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectRequired.ts
new file mode 100644
index 0000000000..fa8c68f2bc
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectRequired.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectRequired } from "../../structures/ObjectRequired";
+
+export const test_notation_createValidateKebab_ObjectRequired = (): void =>
+  _test_notation_validateGeneral("ObjectRequired")<ObjectRequired>(
+    ObjectRequired,
+  )<typia.KebabCase<ObjectRequired>>({
+    convert: typia.notations.createValidateKebab<ObjectRequired>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectRequired>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSequenceProtobuf.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSequenceProtobuf.ts
new file mode 100644
index 0000000000..3c710de3d2
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSequenceProtobuf.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectSequenceProtobuf } from "../../structures/ObjectSequenceProtobuf";
+
+export const test_notation_createValidateKebab_ObjectSequenceProtobuf =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectSequenceProtobuf",
+    )<ObjectSequenceProtobuf>(ObjectSequenceProtobuf)<
+      typia.KebabCase<ObjectSequenceProtobuf>
+    >({
+      convert: typia.notations.createValidateKebab<ObjectSequenceProtobuf>(),
+      assert: typia.createAssert<typia.KebabCase<ObjectSequenceProtobuf>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimple.ts
new file mode 100644
index 0000000000..70a46c1396
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectSimple } from "../../structures/ObjectSimple";
+
+export const test_notation_createValidateKebab_ObjectSimple = (): void =>
+  _test_notation_validateGeneral("ObjectSimple")<ObjectSimple>(ObjectSimple)<
+    typia.KebabCase<ObjectSimple>
+  >({
+    convert: typia.notations.createValidateKebab<ObjectSimple>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectSimple>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobuf.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobuf.ts
new file mode 100644
index 0000000000..1cd50dd6c4
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobuf.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectSimpleProtobuf } from "../../structures/ObjectSimpleProtobuf";
+
+export const test_notation_createValidateKebab_ObjectSimpleProtobuf =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectSimpleProtobuf",
+    )<ObjectSimpleProtobuf>(ObjectSimpleProtobuf)<
+      typia.KebabCase<ObjectSimpleProtobuf>
+    >({
+      convert: typia.notations.createValidateKebab<ObjectSimpleProtobuf>(),
+      assert: typia.createAssert<typia.KebabCase<ObjectSimpleProtobuf>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobufNullable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobufNullable.ts
new file mode 100644
index 0000000000..bc05434ae8
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobufNullable.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectSimpleProtobufNullable } from "../../structures/ObjectSimpleProtobufNullable";
+
+export const test_notation_createValidateKebab_ObjectSimpleProtobufNullable =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectSimpleProtobufNullable",
+    )<ObjectSimpleProtobufNullable>(ObjectSimpleProtobufNullable)<
+      typia.KebabCase<ObjectSimpleProtobufNullable>
+    >({
+      convert:
+        typia.notations.createValidateKebab<ObjectSimpleProtobufNullable>(),
+      assert:
+        typia.createAssert<typia.KebabCase<ObjectSimpleProtobufNullable>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobufOptional.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobufOptional.ts
new file mode 100644
index 0000000000..37a01ec78c
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectSimpleProtobufOptional.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectSimpleProtobufOptional } from "../../structures/ObjectSimpleProtobufOptional";
+
+export const test_notation_createValidateKebab_ObjectSimpleProtobufOptional =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectSimpleProtobufOptional",
+    )<ObjectSimpleProtobufOptional>(ObjectSimpleProtobufOptional)<
+      typia.KebabCase<ObjectSimpleProtobufOptional>
+    >({
+      convert:
+        typia.notations.createValidateKebab<ObjectSimpleProtobufOptional>(),
+      assert:
+        typia.createAssert<typia.KebabCase<ObjectSimpleProtobufOptional>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectTuple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectTuple.ts
new file mode 100644
index 0000000000..9a2d54f41b
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectTuple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectTuple } from "../../structures/ObjectTuple";
+
+export const test_notation_createValidateKebab_ObjectTuple = (): void =>
+  _test_notation_validateGeneral("ObjectTuple")<ObjectTuple>(ObjectTuple)<
+    typia.KebabCase<ObjectTuple>
+  >({
+    convert: typia.notations.createValidateKebab<ObjectTuple>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectTuple>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUndefined.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUndefined.ts
new file mode 100644
index 0000000000..438370af45
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUndefined.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUndefined } from "../../structures/ObjectUndefined";
+
+export const test_notation_createValidateKebab_ObjectUndefined = (): void =>
+  _test_notation_validateGeneral("ObjectUndefined")<ObjectUndefined>(
+    ObjectUndefined,
+  )<typia.KebabCase<ObjectUndefined>>({
+    convert: typia.notations.createValidateKebab<ObjectUndefined>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectUndefined>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionComposite.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionComposite.ts
new file mode 100644
index 0000000000..80528e711f
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionComposite.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUnionComposite } from "../../structures/ObjectUnionComposite";
+
+export const test_notation_createValidateKebab_ObjectUnionComposite =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectUnionComposite",
+    )<ObjectUnionComposite>(ObjectUnionComposite)<
+      typia.KebabCase<ObjectUnionComposite>
+    >({
+      convert: typia.notations.createValidateKebab<ObjectUnionComposite>(),
+      assert: typia.createAssert<typia.KebabCase<ObjectUnionComposite>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionCompositePointer.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionCompositePointer.ts
new file mode 100644
index 0000000000..f744fee1d4
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionCompositePointer.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUnionCompositePointer } from "../../structures/ObjectUnionCompositePointer";
+
+export const test_notation_createValidateKebab_ObjectUnionCompositePointer =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectUnionCompositePointer",
+    )<ObjectUnionCompositePointer>(ObjectUnionCompositePointer)<
+      typia.KebabCase<ObjectUnionCompositePointer>
+    >({
+      convert:
+        typia.notations.createValidateKebab<ObjectUnionCompositePointer>(),
+      assert:
+        typia.createAssert<typia.KebabCase<ObjectUnionCompositePointer>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionDouble.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionDouble.ts
new file mode 100644
index 0000000000..3dd187f1a8
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionDouble.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUnionDouble } from "../../structures/ObjectUnionDouble";
+
+export const test_notation_createValidateKebab_ObjectUnionDouble = (): void =>
+  _test_notation_validateGeneral("ObjectUnionDouble")<ObjectUnionDouble>(
+    ObjectUnionDouble,
+  )<typia.KebabCase<ObjectUnionDouble>>({
+    convert: typia.notations.createValidateKebab<ObjectUnionDouble>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectUnionDouble>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionExplicit.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionExplicit.ts
new file mode 100644
index 0000000000..71b84ffffd
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionExplicit.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUnionExplicit } from "../../structures/ObjectUnionExplicit";
+
+export const test_notation_createValidateKebab_ObjectUnionExplicit = (): void =>
+  _test_notation_validateGeneral("ObjectUnionExplicit")<ObjectUnionExplicit>(
+    ObjectUnionExplicit,
+  )<typia.KebabCase<ObjectUnionExplicit>>({
+    convert: typia.notations.createValidateKebab<ObjectUnionExplicit>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectUnionExplicit>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionExplicitPointer.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionExplicitPointer.ts
new file mode 100644
index 0000000000..499bf4fda2
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionExplicitPointer.ts
@@ -0,0 +1,16 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUnionExplicitPointer } from "../../structures/ObjectUnionExplicitPointer";
+
+export const test_notation_createValidateKebab_ObjectUnionExplicitPointer =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectUnionExplicitPointer",
+    )<ObjectUnionExplicitPointer>(ObjectUnionExplicitPointer)<
+      typia.KebabCase<ObjectUnionExplicitPointer>
+    >({
+      convert:
+        typia.notations.createValidateKebab<ObjectUnionExplicitPointer>(),
+      assert: typia.createAssert<typia.KebabCase<ObjectUnionExplicitPointer>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionImplicit.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionImplicit.ts
new file mode 100644
index 0000000000..2e7128336b
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionImplicit.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUnionImplicit } from "../../structures/ObjectUnionImplicit";
+
+export const test_notation_createValidateKebab_ObjectUnionImplicit = (): void =>
+  _test_notation_validateGeneral("ObjectUnionImplicit")<ObjectUnionImplicit>(
+    ObjectUnionImplicit,
+  )<typia.KebabCase<ObjectUnionImplicit>>({
+    convert: typia.notations.createValidateKebab<ObjectUnionImplicit>(),
+    assert: typia.createAssert<typia.KebabCase<ObjectUnionImplicit>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionNonPredictable.ts b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionNonPredictable.ts
new file mode 100644
index 0000000000..926299b198
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_ObjectUnionNonPredictable.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUnionNonPredictable } from "../../structures/ObjectUnionNonPredictable";
+
+export const test_notation_createValidateKebab_ObjectUnionNonPredictable =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectUnionNonPredictable",
+    )<ObjectUnionNonPredictable>(ObjectUnionNonPredictable)<
+      typia.KebabCase<ObjectUnionNonPredictable>
+    >({
+      convert: typia.notations.createValidateKebab<ObjectUnionNonPredictable>(),
+      assert: typia.createAssert<typia.KebabCase<ObjectUnionNonPredictable>>(),
+    });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_SetAlias.ts b/test/src/features/notation.createKebab/test_notation_createKebab_SetAlias.ts
new file mode 100644
index 0000000000..46050581b2
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_SetAlias.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { SetAlias } from "../../structures/SetAlias";
+
+export const test_notation_createValidateKebab_SetAlias = (): void =>
+  _test_notation_validateGeneral("SetAlias")<SetAlias>(SetAlias)<
+    typia.KebabCase<SetAlias>
+  >({
+    convert: typia.notations.createValidateKebab<SetAlias>(),
+    assert: typia.createAssert<typia.KebabCase<SetAlias>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_SetSimple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_SetSimple.ts
new file mode 100644
index 0000000000..e296c0d7f2
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_SetSimple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { SetSimple } from "../../structures/SetSimple";
+
+export const test_notation_createValidateKebab_SetSimple = (): void =>
+  _test_notation_validateGeneral("SetSimple")<SetSimple>(SetSimple)<
+    typia.KebabCase<SetSimple>
+  >({
+    convert: typia.notations.createValidateKebab<SetSimple>(),
+    assert: typia.createAssert<typia.KebabCase<SetSimple>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_SetUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_SetUnion.ts
new file mode 100644
index 0000000000..258592eafb
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_SetUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { SetUnion } from "../../structures/SetUnion";
+
+export const test_notation_createValidateKebab_SetUnion = (): void =>
+  _test_notation_validateGeneral("SetUnion")<SetUnion>(SetUnion)<
+    typia.KebabCase<SetUnion>
+  >({
+    convert: typia.notations.createValidateKebab<SetUnion>(),
+    assert: typia.createAssert<typia.KebabCase<SetUnion>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TemplateAtomic.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TemplateAtomic.ts
new file mode 100644
index 0000000000..d32a01d92a
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TemplateAtomic.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TemplateAtomic } from "../../structures/TemplateAtomic";
+
+export const test_notation_createValidateKebab_TemplateAtomic = (): void =>
+  _test_notation_validateGeneral("TemplateAtomic")<TemplateAtomic>(
+    TemplateAtomic,
+  )<typia.KebabCase<TemplateAtomic>>({
+    convert: typia.notations.createValidateKebab<TemplateAtomic>(),
+    assert: typia.createAssert<typia.KebabCase<TemplateAtomic>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TemplateConstant.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TemplateConstant.ts
new file mode 100644
index 0000000000..13c8735e0c
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TemplateConstant.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TemplateConstant } from "../../structures/TemplateConstant";
+
+export const test_notation_createValidateKebab_TemplateConstant = (): void =>
+  _test_notation_validateGeneral("TemplateConstant")<TemplateConstant>(
+    TemplateConstant,
+  )<typia.KebabCase<TemplateConstant>>({
+    convert: typia.notations.createValidateKebab<TemplateConstant>(),
+    assert: typia.createAssert<typia.KebabCase<TemplateConstant>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TemplateUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TemplateUnion.ts
new file mode 100644
index 0000000000..8f9160e8b8
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TemplateUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TemplateUnion } from "../../structures/TemplateUnion";
+
+export const test_notation_createValidateKebab_TemplateUnion = (): void =>
+  _test_notation_validateGeneral("TemplateUnion")<TemplateUnion>(TemplateUnion)<
+    typia.KebabCase<TemplateUnion>
+  >({
+    convert: typia.notations.createValidateKebab<TemplateUnion>(),
+    assert: typia.createAssert<typia.KebabCase<TemplateUnion>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TupleHierarchical.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TupleHierarchical.ts
new file mode 100644
index 0000000000..a5a41a9302
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TupleHierarchical.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TupleHierarchical } from "../../structures/TupleHierarchical";
+
+export const test_notation_createValidateKebab_TupleHierarchical = (): void =>
+  _test_notation_validateGeneral("TupleHierarchical")<TupleHierarchical>(
+    TupleHierarchical,
+  )<typia.KebabCase<TupleHierarchical>>({
+    convert: typia.notations.createValidateKebab<TupleHierarchical>(),
+    assert: typia.createAssert<typia.KebabCase<TupleHierarchical>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TupleOptional.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TupleOptional.ts
new file mode 100644
index 0000000000..6b308beaa0
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TupleOptional.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TupleOptional } from "../../structures/TupleOptional";
+
+export const test_notation_createValidateKebab_TupleOptional = (): void =>
+  _test_notation_validateGeneral("TupleOptional")<TupleOptional>(TupleOptional)<
+    typia.KebabCase<TupleOptional>
+  >({
+    convert: typia.notations.createValidateKebab<TupleOptional>(),
+    assert: typia.createAssert<typia.KebabCase<TupleOptional>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestArray.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestArray.ts
new file mode 100644
index 0000000000..3a602211f4
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestArray.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TupleRestArray } from "../../structures/TupleRestArray";
+
+export const test_notation_createValidateKebab_TupleRestArray = (): void =>
+  _test_notation_validateGeneral("TupleRestArray")<TupleRestArray>(
+    TupleRestArray,
+  )<typia.KebabCase<TupleRestArray>>({
+    convert: typia.notations.createValidateKebab<TupleRestArray>(),
+    assert: typia.createAssert<typia.KebabCase<TupleRestArray>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestAtomic.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestAtomic.ts
new file mode 100644
index 0000000000..6661da70fe
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestAtomic.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TupleRestAtomic } from "../../structures/TupleRestAtomic";
+
+export const test_notation_createValidateKebab_TupleRestAtomic = (): void =>
+  _test_notation_validateGeneral("TupleRestAtomic")<TupleRestAtomic>(
+    TupleRestAtomic,
+  )<typia.KebabCase<TupleRestAtomic>>({
+    convert: typia.notations.createValidateKebab<TupleRestAtomic>(),
+    assert: typia.createAssert<typia.KebabCase<TupleRestAtomic>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestObject.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestObject.ts
new file mode 100644
index 0000000000..8f20b55a3f
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TupleRestObject.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TupleRestObject } from "../../structures/TupleRestObject";
+
+export const test_notation_createValidateKebab_TupleRestObject = (): void =>
+  _test_notation_validateGeneral("TupleRestObject")<TupleRestObject>(
+    TupleRestObject,
+  )<typia.KebabCase<TupleRestObject>>({
+    convert: typia.notations.createValidateKebab<TupleRestObject>(),
+    assert: typia.createAssert<typia.KebabCase<TupleRestObject>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TupleUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TupleUnion.ts
new file mode 100644
index 0000000000..f5ec1839c0
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TupleUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TupleUnion } from "../../structures/TupleUnion";
+
+export const test_notation_createValidateKebab_TupleUnion = (): void =>
+  _test_notation_validateGeneral("TupleUnion")<TupleUnion>(TupleUnion)<
+    typia.KebabCase<TupleUnion>
+  >({
+    convert: typia.notations.createValidateKebab<TupleUnion>(),
+    assert: typia.createAssert<typia.KebabCase<TupleUnion>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagArray.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagArray.ts
new file mode 100644
index 0000000000..fe1ef7c08f
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagArray.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagArray } from "../../structures/TypeTagArray";
+
+export const test_notation_createValidateKebab_TypeTagArray = (): void =>
+  _test_notation_validateGeneral("TypeTagArray")<TypeTagArray>(TypeTagArray)<
+    typia.KebabCase<TypeTagArray>
+  >({
+    convert: typia.notations.createValidateKebab<TypeTagArray>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagArray>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagArrayUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagArrayUnion.ts
new file mode 100644
index 0000000000..17dc29f565
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagArrayUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagArrayUnion } from "../../structures/TypeTagArrayUnion";
+
+export const test_notation_createValidateKebab_TypeTagArrayUnion = (): void =>
+  _test_notation_validateGeneral("TypeTagArrayUnion")<TypeTagArrayUnion>(
+    TypeTagArrayUnion,
+  )<typia.KebabCase<TypeTagArrayUnion>>({
+    convert: typia.notations.createValidateKebab<TypeTagArrayUnion>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagArrayUnion>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagAtomicUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagAtomicUnion.ts
new file mode 100644
index 0000000000..2e255d5954
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagAtomicUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagAtomicUnion } from "../../structures/TypeTagAtomicUnion";
+
+export const test_notation_createValidateKebab_TypeTagAtomicUnion = (): void =>
+  _test_notation_validateGeneral("TypeTagAtomicUnion")<TypeTagAtomicUnion>(
+    TypeTagAtomicUnion,
+  )<typia.KebabCase<TypeTagAtomicUnion>>({
+    convert: typia.notations.createValidateKebab<TypeTagAtomicUnion>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagAtomicUnion>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagBigInt.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagBigInt.ts
new file mode 100644
index 0000000000..ad86f1fcc1
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagBigInt.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagBigInt } from "../../structures/TypeTagBigInt";
+
+export const test_notation_createValidateKebab_TypeTagBigInt = (): void =>
+  _test_notation_validateGeneral("TypeTagBigInt")<TypeTagBigInt>(TypeTagBigInt)<
+    typia.KebabCase<TypeTagBigInt>
+  >({
+    convert: typia.notations.createValidateKebab<TypeTagBigInt>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagBigInt>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagCustom.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagCustom.ts
new file mode 100644
index 0000000000..b51c23ea11
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagCustom.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagCustom } from "../../structures/TypeTagCustom";
+
+export const test_notation_createValidateKebab_TypeTagCustom = (): void =>
+  _test_notation_validateGeneral("TypeTagCustom")<TypeTagCustom>(TypeTagCustom)<
+    typia.KebabCase<TypeTagCustom>
+  >({
+    convert: typia.notations.createValidateKebab<TypeTagCustom>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagCustom>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagDefault.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagDefault.ts
new file mode 100644
index 0000000000..966dfc1ce8
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagDefault.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagDefault } from "../../structures/TypeTagDefault";
+
+export const test_notation_createValidateKebab_TypeTagDefault = (): void =>
+  _test_notation_validateGeneral("TypeTagDefault")<TypeTagDefault>(
+    TypeTagDefault,
+  )<typia.KebabCase<TypeTagDefault>>({
+    convert: typia.notations.createValidateKebab<TypeTagDefault>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagDefault>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagFormat.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagFormat.ts
new file mode 100644
index 0000000000..75bfc9097b
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagFormat.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagFormat } from "../../structures/TypeTagFormat";
+
+export const test_notation_createValidateKebab_TypeTagFormat = (): void =>
+  _test_notation_validateGeneral("TypeTagFormat")<TypeTagFormat>(TypeTagFormat)<
+    typia.KebabCase<TypeTagFormat>
+  >({
+    convert: typia.notations.createValidateKebab<TypeTagFormat>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagFormat>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagInfinite.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagInfinite.ts
new file mode 100644
index 0000000000..0d03fc494c
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagInfinite.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagInfinite } from "../../structures/TypeTagInfinite";
+
+export const test_notation_createValidateKebab_TypeTagInfinite = (): void =>
+  _test_notation_validateGeneral("TypeTagInfinite")<TypeTagInfinite>(
+    TypeTagInfinite,
+  )<typia.KebabCase<TypeTagInfinite>>({
+    convert: typia.notations.createValidateKebab<TypeTagInfinite>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagInfinite>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagLength.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagLength.ts
new file mode 100644
index 0000000000..2b11854d9b
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagLength.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagLength } from "../../structures/TypeTagLength";
+
+export const test_notation_createValidateKebab_TypeTagLength = (): void =>
+  _test_notation_validateGeneral("TypeTagLength")<TypeTagLength>(TypeTagLength)<
+    typia.KebabCase<TypeTagLength>
+  >({
+    convert: typia.notations.createValidateKebab<TypeTagLength>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagLength>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagMatrix.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagMatrix.ts
new file mode 100644
index 0000000000..0d43458c6d
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagMatrix.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagMatrix } from "../../structures/TypeTagMatrix";
+
+export const test_notation_createValidateKebab_TypeTagMatrix = (): void =>
+  _test_notation_validateGeneral("TypeTagMatrix")<TypeTagMatrix>(TypeTagMatrix)<
+    typia.KebabCase<TypeTagMatrix>
+  >({
+    convert: typia.notations.createValidateKebab<TypeTagMatrix>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagMatrix>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagNaN.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagNaN.ts
new file mode 100644
index 0000000000..40d951dc8e
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagNaN.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagNaN } from "../../structures/TypeTagNaN";
+
+export const test_notation_createValidateKebab_TypeTagNaN = (): void =>
+  _test_notation_validateGeneral("TypeTagNaN")<TypeTagNaN>(TypeTagNaN)<
+    typia.KebabCase<TypeTagNaN>
+  >({
+    convert: typia.notations.createValidateKebab<TypeTagNaN>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagNaN>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagObjectUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagObjectUnion.ts
new file mode 100644
index 0000000000..fcf2cf4eb2
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagObjectUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagObjectUnion } from "../../structures/TypeTagObjectUnion";
+
+export const test_notation_createValidateKebab_TypeTagObjectUnion = (): void =>
+  _test_notation_validateGeneral("TypeTagObjectUnion")<TypeTagObjectUnion>(
+    TypeTagObjectUnion,
+  )<typia.KebabCase<TypeTagObjectUnion>>({
+    convert: typia.notations.createValidateKebab<TypeTagObjectUnion>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagObjectUnion>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagPattern.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagPattern.ts
new file mode 100644
index 0000000000..81cfdbdf0c
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagPattern.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagPattern } from "../../structures/TypeTagPattern";
+
+export const test_notation_createValidateKebab_TypeTagPattern = (): void =>
+  _test_notation_validateGeneral("TypeTagPattern")<TypeTagPattern>(
+    TypeTagPattern,
+  )<typia.KebabCase<TypeTagPattern>>({
+    convert: typia.notations.createValidateKebab<TypeTagPattern>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagPattern>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagRange.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagRange.ts
new file mode 100644
index 0000000000..bbb57a7ba3
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagRange.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagRange } from "../../structures/TypeTagRange";
+
+export const test_notation_createValidateKebab_TypeTagRange = (): void =>
+  _test_notation_validateGeneral("TypeTagRange")<TypeTagRange>(TypeTagRange)<
+    typia.KebabCase<TypeTagRange>
+  >({
+    convert: typia.notations.createValidateKebab<TypeTagRange>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagRange>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagRangeBigInt.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagRangeBigInt.ts
new file mode 100644
index 0000000000..70c9b9d015
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagRangeBigInt.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagRangeBigInt } from "../../structures/TypeTagRangeBigInt";
+
+export const test_notation_createValidateKebab_TypeTagRangeBigInt = (): void =>
+  _test_notation_validateGeneral("TypeTagRangeBigInt")<TypeTagRangeBigInt>(
+    TypeTagRangeBigInt,
+  )<typia.KebabCase<TypeTagRangeBigInt>>({
+    convert: typia.notations.createValidateKebab<TypeTagRangeBigInt>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagRangeBigInt>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTuple.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTuple.ts
new file mode 100644
index 0000000000..a1f79d17a8
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTuple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagTuple } from "../../structures/TypeTagTuple";
+
+export const test_notation_createValidateKebab_TypeTagTuple = (): void =>
+  _test_notation_validateGeneral("TypeTagTuple")<TypeTagTuple>(TypeTagTuple)<
+    typia.KebabCase<TypeTagTuple>
+  >({
+    convert: typia.notations.createValidateKebab<TypeTagTuple>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagTuple>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagType.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagType.ts
new file mode 100644
index 0000000000..df99fa9713
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagType.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagType } from "../../structures/TypeTagType";
+
+export const test_notation_createValidateKebab_TypeTagType = (): void =>
+  _test_notation_validateGeneral("TypeTagType")<TypeTagType>(TypeTagType)<
+    typia.KebabCase<TypeTagType>
+  >({
+    convert: typia.notations.createValidateKebab<TypeTagType>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagType>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTypeBigInt.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTypeBigInt.ts
new file mode 100644
index 0000000000..4a3764bba9
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTypeBigInt.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagTypeBigInt } from "../../structures/TypeTagTypeBigInt";
+
+export const test_notation_createValidateKebab_TypeTagTypeBigInt = (): void =>
+  _test_notation_validateGeneral("TypeTagTypeBigInt")<TypeTagTypeBigInt>(
+    TypeTagTypeBigInt,
+  )<typia.KebabCase<TypeTagTypeBigInt>>({
+    convert: typia.notations.createValidateKebab<TypeTagTypeBigInt>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagTypeBigInt>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTypeUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTypeUnion.ts
new file mode 100644
index 0000000000..caac788d3a
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_TypeTagTypeUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagTypeUnion } from "../../structures/TypeTagTypeUnion";
+
+export const test_notation_createValidateKebab_TypeTagTypeUnion = (): void =>
+  _test_notation_validateGeneral("TypeTagTypeUnion")<TypeTagTypeUnion>(
+    TypeTagTypeUnion,
+  )<typia.KebabCase<TypeTagTypeUnion>>({
+    convert: typia.notations.createValidateKebab<TypeTagTypeUnion>(),
+    assert: typia.createAssert<typia.KebabCase<TypeTagTypeUnion>>(),
+  });
diff --git a/test/src/features/notation.createKebab/test_notation_createKebab_UltimateUnion.ts b/test/src/features/notation.createKebab/test_notation_createKebab_UltimateUnion.ts
new file mode 100644
index 0000000000..2dc6f79248
--- /dev/null
+++ b/test/src/features/notation.createKebab/test_notation_createKebab_UltimateUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { UltimateUnion } from "../../structures/UltimateUnion";
+
+export const test_notation_createValidateKebab_UltimateUnion = (): void =>
+  _test_notation_validateGeneral("UltimateUnion")<UltimateUnion>(UltimateUnion)<
+    typia.KebabCase<UltimateUnion>
+  >({
+    convert: typia.notations.createValidateKebab<UltimateUnion>(),
+    assert: typia.createAssert<typia.KebabCase<UltimateUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayAny.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayAny.ts
new file mode 100644
index 0000000000..178102908e
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayAny.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayAny } from "../../structures/ArrayAny";
+
+export const test_notation_validateKebab_ArrayAny = (): void =>
+  _test_notation_validateGeneral("ArrayAny")<ArrayAny>(ArrayAny)<
+    typia.KebabCase<ArrayAny>
+  >({
+    convert: (input) => typia.notations.validateKebab<ArrayAny>(input),
+    assert: typia.createAssert<typia.KebabCase<ArrayAny>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayAtomicAlias.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayAtomicAlias.ts
new file mode 100644
index 0000000000..34e530fe53
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayAtomicAlias.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayAtomicAlias } from "../../structures/ArrayAtomicAlias";
+
+export const test_notation_validateKebab_ArrayAtomicAlias = (): void =>
+  _test_notation_validateGeneral("ArrayAtomicAlias")<ArrayAtomicAlias>(
+    ArrayAtomicAlias,
+  )<typia.KebabCase<ArrayAtomicAlias>>({
+    convert: (input) => typia.notations.validateKebab<ArrayAtomicAlias>(input),
+    assert: typia.createAssert<typia.KebabCase<ArrayAtomicAlias>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayAtomicSimple.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayAtomicSimple.ts
new file mode 100644
index 0000000000..1bbdad06b1
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayAtomicSimple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayAtomicSimple } from "../../structures/ArrayAtomicSimple";
+
+export const test_notation_validateKebab_ArrayAtomicSimple = (): void =>
+  _test_notation_validateGeneral("ArrayAtomicSimple")<ArrayAtomicSimple>(
+    ArrayAtomicSimple,
+  )<typia.KebabCase<ArrayAtomicSimple>>({
+    convert: (input) => typia.notations.validateKebab<ArrayAtomicSimple>(input),
+    assert: typia.createAssert<typia.KebabCase<ArrayAtomicSimple>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayHierarchical.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayHierarchical.ts
new file mode 100644
index 0000000000..9dbeceb457
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayHierarchical.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayHierarchical } from "../../structures/ArrayHierarchical";
+
+export const test_notation_validateKebab_ArrayHierarchical = (): void =>
+  _test_notation_validateGeneral("ArrayHierarchical")<ArrayHierarchical>(
+    ArrayHierarchical,
+  )<typia.KebabCase<ArrayHierarchical>>({
+    convert: (input) => typia.notations.validateKebab<ArrayHierarchical>(input),
+    assert: typia.createAssert<typia.KebabCase<ArrayHierarchical>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayHierarchicalPointer.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayHierarchicalPointer.ts
new file mode 100644
index 0000000000..a94b34ec47
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayHierarchicalPointer.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayHierarchicalPointer } from "../../structures/ArrayHierarchicalPointer";
+
+export const test_notation_validateKebab_ArrayHierarchicalPointer = (): void =>
+  _test_notation_validateGeneral(
+    "ArrayHierarchicalPointer",
+  )<ArrayHierarchicalPointer>(ArrayHierarchicalPointer)<
+    typia.KebabCase<ArrayHierarchicalPointer>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<ArrayHierarchicalPointer>(input),
+    assert: typia.createAssert<typia.KebabCase<ArrayHierarchicalPointer>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayMatrix.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayMatrix.ts
new file mode 100644
index 0000000000..2d82964cc7
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayMatrix.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayMatrix } from "../../structures/ArrayMatrix";
+
+export const test_notation_validateKebab_ArrayMatrix = (): void =>
+  _test_notation_validateGeneral("ArrayMatrix")<ArrayMatrix>(ArrayMatrix)<
+    typia.KebabCase<ArrayMatrix>
+  >({
+    convert: (input) => typia.notations.validateKebab<ArrayMatrix>(input),
+    assert: typia.createAssert<typia.KebabCase<ArrayMatrix>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursive.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursive.ts
new file mode 100644
index 0000000000..815720fbf1
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursive.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRecursive } from "../../structures/ArrayRecursive";
+
+export const test_notation_validateKebab_ArrayRecursive = (): void =>
+  _test_notation_validateGeneral("ArrayRecursive")<ArrayRecursive>(
+    ArrayRecursive,
+  )<typia.KebabCase<ArrayRecursive>>({
+    convert: (input) => typia.notations.validateKebab<ArrayRecursive>(input),
+    assert: typia.createAssert<typia.KebabCase<ArrayRecursive>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionExplicit.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionExplicit.ts
new file mode 100644
index 0000000000..3ec3611cfb
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionExplicit.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRecursiveUnionExplicit } from "../../structures/ArrayRecursiveUnionExplicit";
+
+export const test_notation_validateKebab_ArrayRecursiveUnionExplicit =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArrayRecursiveUnionExplicit",
+    )<ArrayRecursiveUnionExplicit>(ArrayRecursiveUnionExplicit)<
+      typia.KebabCase<ArrayRecursiveUnionExplicit>
+    >({
+      convert: (input) =>
+        typia.notations.validateKebab<ArrayRecursiveUnionExplicit>(input),
+      assert:
+        typia.createAssert<typia.KebabCase<ArrayRecursiveUnionExplicit>>(),
+    });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionExplicitPointer.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionExplicitPointer.ts
new file mode 100644
index 0000000000..a96e68f7e9
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionExplicitPointer.ts
@@ -0,0 +1,21 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRecursiveUnionExplicitPointer } from "../../structures/ArrayRecursiveUnionExplicitPointer";
+
+export const test_notation_validateKebab_ArrayRecursiveUnionExplicitPointer =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArrayRecursiveUnionExplicitPointer",
+    )<ArrayRecursiveUnionExplicitPointer>(ArrayRecursiveUnionExplicitPointer)<
+      typia.KebabCase<ArrayRecursiveUnionExplicitPointer>
+    >({
+      convert: (input) =>
+        typia.notations.validateKebab<ArrayRecursiveUnionExplicitPointer>(
+          input,
+        ),
+      assert:
+        typia.createAssert<
+          typia.KebabCase<ArrayRecursiveUnionExplicitPointer>
+        >(),
+    });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionImplicit.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionImplicit.ts
new file mode 100644
index 0000000000..17f43d5fc9
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRecursiveUnionImplicit.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRecursiveUnionImplicit } from "../../structures/ArrayRecursiveUnionImplicit";
+
+export const test_notation_validateKebab_ArrayRecursiveUnionImplicit =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArrayRecursiveUnionImplicit",
+    )<ArrayRecursiveUnionImplicit>(ArrayRecursiveUnionImplicit)<
+      typia.KebabCase<ArrayRecursiveUnionImplicit>
+    >({
+      convert: (input) =>
+        typia.notations.validateKebab<ArrayRecursiveUnionImplicit>(input),
+      assert:
+        typia.createAssert<typia.KebabCase<ArrayRecursiveUnionImplicit>>(),
+    });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedNullable.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedNullable.ts
new file mode 100644
index 0000000000..d8a1d7326e
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedNullable.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRepeatedNullable } from "../../structures/ArrayRepeatedNullable";
+
+export const test_notation_validateKebab_ArrayRepeatedNullable = (): void =>
+  _test_notation_validateGeneral(
+    "ArrayRepeatedNullable",
+  )<ArrayRepeatedNullable>(ArrayRepeatedNullable)<
+    typia.KebabCase<ArrayRepeatedNullable>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<ArrayRepeatedNullable>(input),
+    assert: typia.createAssert<typia.KebabCase<ArrayRepeatedNullable>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedOptional.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedOptional.ts
new file mode 100644
index 0000000000..dc9a028031
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedOptional.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRepeatedOptional } from "../../structures/ArrayRepeatedOptional";
+
+export const test_notation_validateKebab_ArrayRepeatedOptional = (): void =>
+  _test_notation_validateGeneral(
+    "ArrayRepeatedOptional",
+  )<ArrayRepeatedOptional>(ArrayRepeatedOptional)<
+    typia.KebabCase<ArrayRepeatedOptional>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<ArrayRepeatedOptional>(input),
+    assert: typia.createAssert<typia.KebabCase<ArrayRepeatedOptional>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedRequired.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedRequired.ts
new file mode 100644
index 0000000000..954580345b
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedRequired.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRepeatedRequired } from "../../structures/ArrayRepeatedRequired";
+
+export const test_notation_validateKebab_ArrayRepeatedRequired = (): void =>
+  _test_notation_validateGeneral(
+    "ArrayRepeatedRequired",
+  )<ArrayRepeatedRequired>(ArrayRepeatedRequired)<
+    typia.KebabCase<ArrayRepeatedRequired>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<ArrayRepeatedRequired>(input),
+    assert: typia.createAssert<typia.KebabCase<ArrayRepeatedRequired>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedUnion.ts
new file mode 100644
index 0000000000..a9b4603022
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedUnion.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRepeatedUnion } from "../../structures/ArrayRepeatedUnion";
+
+export const test_notation_validateKebab_ArrayRepeatedUnion = (): void =>
+  _test_notation_validateGeneral("ArrayRepeatedUnion")<ArrayRepeatedUnion>(
+    ArrayRepeatedUnion,
+  )<typia.KebabCase<ArrayRepeatedUnion>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ArrayRepeatedUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<ArrayRepeatedUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedUnionWithTuple.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedUnionWithTuple.ts
new file mode 100644
index 0000000000..05f0858062
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayRepeatedUnionWithTuple.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayRepeatedUnionWithTuple } from "../../structures/ArrayRepeatedUnionWithTuple";
+
+export const test_notation_validateKebab_ArrayRepeatedUnionWithTuple =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArrayRepeatedUnionWithTuple",
+    )<ArrayRepeatedUnionWithTuple>(ArrayRepeatedUnionWithTuple)<
+      typia.KebabCase<ArrayRepeatedUnionWithTuple>
+    >({
+      convert: (input) =>
+        typia.notations.validateKebab<ArrayRepeatedUnionWithTuple>(input),
+      assert:
+        typia.createAssert<typia.KebabCase<ArrayRepeatedUnionWithTuple>>(),
+    });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArraySimple.ts b/test/src/features/notation.kebab/test_notation_kebab_ArraySimple.ts
new file mode 100644
index 0000000000..28883a022d
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArraySimple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArraySimple } from "../../structures/ArraySimple";
+
+export const test_notation_validateKebab_ArraySimple = (): void =>
+  _test_notation_validateGeneral("ArraySimple")<ArraySimple>(ArraySimple)<
+    typia.KebabCase<ArraySimple>
+  >({
+    convert: (input) => typia.notations.validateKebab<ArraySimple>(input),
+    assert: typia.createAssert<typia.KebabCase<ArraySimple>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobuf.ts b/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobuf.ts
new file mode 100644
index 0000000000..369810e264
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobuf.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArraySimpleProtobuf } from "../../structures/ArraySimpleProtobuf";
+
+export const test_notation_validateKebab_ArraySimpleProtobuf = (): void =>
+  _test_notation_validateGeneral("ArraySimpleProtobuf")<ArraySimpleProtobuf>(
+    ArraySimpleProtobuf,
+  )<typia.KebabCase<ArraySimpleProtobuf>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ArraySimpleProtobuf>(input),
+    assert: typia.createAssert<typia.KebabCase<ArraySimpleProtobuf>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobufNullable.ts b/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobufNullable.ts
new file mode 100644
index 0000000000..e7785ff428
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobufNullable.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArraySimpleProtobufNullable } from "../../structures/ArraySimpleProtobufNullable";
+
+export const test_notation_validateKebab_ArraySimpleProtobufNullable =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArraySimpleProtobufNullable",
+    )<ArraySimpleProtobufNullable>(ArraySimpleProtobufNullable)<
+      typia.KebabCase<ArraySimpleProtobufNullable>
+    >({
+      convert: (input) =>
+        typia.notations.validateKebab<ArraySimpleProtobufNullable>(input),
+      assert:
+        typia.createAssert<typia.KebabCase<ArraySimpleProtobufNullable>>(),
+    });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobufOptional.ts b/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobufOptional.ts
new file mode 100644
index 0000000000..78c1726b78
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArraySimpleProtobufOptional.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArraySimpleProtobufOptional } from "../../structures/ArraySimpleProtobufOptional";
+
+export const test_notation_validateKebab_ArraySimpleProtobufOptional =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ArraySimpleProtobufOptional",
+    )<ArraySimpleProtobufOptional>(ArraySimpleProtobufOptional)<
+      typia.KebabCase<ArraySimpleProtobufOptional>
+    >({
+      convert: (input) =>
+        typia.notations.validateKebab<ArraySimpleProtobufOptional>(input),
+      assert:
+        typia.createAssert<typia.KebabCase<ArraySimpleProtobufOptional>>(),
+    });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ArrayUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_ArrayUnion.ts
new file mode 100644
index 0000000000..99e5d2792c
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ArrayUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ArrayUnion } from "../../structures/ArrayUnion";
+
+export const test_notation_validateKebab_ArrayUnion = (): void =>
+  _test_notation_validateGeneral("ArrayUnion")<ArrayUnion>(ArrayUnion)<
+    typia.KebabCase<ArrayUnion>
+  >({
+    convert: (input) => typia.notations.validateKebab<ArrayUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<ArrayUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_AtomicAlias.ts b/test/src/features/notation.kebab/test_notation_kebab_AtomicAlias.ts
new file mode 100644
index 0000000000..10f3276be9
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_AtomicAlias.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { AtomicAlias } from "../../structures/AtomicAlias";
+
+export const test_notation_validateKebab_AtomicAlias = (): void =>
+  _test_notation_validateGeneral("AtomicAlias")<AtomicAlias>(AtomicAlias)<
+    typia.KebabCase<AtomicAlias>
+  >({
+    convert: (input) => typia.notations.validateKebab<AtomicAlias>(input),
+    assert: typia.createAssert<typia.KebabCase<AtomicAlias>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_AtomicClass.ts b/test/src/features/notation.kebab/test_notation_kebab_AtomicClass.ts
new file mode 100644
index 0000000000..f1df403a7d
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_AtomicClass.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { AtomicClass } from "../../structures/AtomicClass";
+
+export const test_notation_validateKebab_AtomicClass = (): void =>
+  _test_notation_validateGeneral("AtomicClass")<AtomicClass>(AtomicClass)<
+    typia.KebabCase<AtomicClass>
+  >({
+    convert: (input) => typia.notations.validateKebab<AtomicClass>(input),
+    assert: typia.createAssert<typia.KebabCase<AtomicClass>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_AtomicIntersection.ts b/test/src/features/notation.kebab/test_notation_kebab_AtomicIntersection.ts
new file mode 100644
index 0000000000..628d76e11b
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_AtomicIntersection.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { AtomicIntersection } from "../../structures/AtomicIntersection";
+
+export const test_notation_validateKebab_AtomicIntersection = (): void =>
+  _test_notation_validateGeneral("AtomicIntersection")<AtomicIntersection>(
+    AtomicIntersection,
+  )<typia.KebabCase<AtomicIntersection>>({
+    convert: (input) =>
+      typia.notations.validateKebab<AtomicIntersection>(input),
+    assert: typia.createAssert<typia.KebabCase<AtomicIntersection>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_AtomicSimple.ts b/test/src/features/notation.kebab/test_notation_kebab_AtomicSimple.ts
new file mode 100644
index 0000000000..f1c73d5363
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_AtomicSimple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { AtomicSimple } from "../../structures/AtomicSimple";
+
+export const test_notation_validateKebab_AtomicSimple = (): void =>
+  _test_notation_validateGeneral("AtomicSimple")<AtomicSimple>(AtomicSimple)<
+    typia.KebabCase<AtomicSimple>
+  >({
+    convert: (input) => typia.notations.validateKebab<AtomicSimple>(input),
+    assert: typia.createAssert<typia.KebabCase<AtomicSimple>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_AtomicUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_AtomicUnion.ts
new file mode 100644
index 0000000000..90466d332f
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_AtomicUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { AtomicUnion } from "../../structures/AtomicUnion";
+
+export const test_notation_validateKebab_AtomicUnion = (): void =>
+  _test_notation_validateGeneral("AtomicUnion")<AtomicUnion>(AtomicUnion)<
+    typia.KebabCase<AtomicUnion>
+  >({
+    convert: (input) => typia.notations.validateKebab<AtomicUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<AtomicUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ClassMethod.ts b/test/src/features/notation.kebab/test_notation_kebab_ClassMethod.ts
new file mode 100644
index 0000000000..822582aee6
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ClassMethod.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ClassMethod } from "../../structures/ClassMethod";
+
+export const test_notation_validateKebab_ClassMethod = (): void =>
+  _test_notation_validateGeneral("ClassMethod")<ClassMethod>(ClassMethod)<
+    typia.KebabCase<ClassMethod>
+  >({
+    convert: (input) => typia.notations.validateKebab<ClassMethod>(input),
+    assert: typia.createAssert<typia.KebabCase<ClassMethod>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ClassNonPublic.ts b/test/src/features/notation.kebab/test_notation_kebab_ClassNonPublic.ts
new file mode 100644
index 0000000000..21a6e80526
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ClassNonPublic.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ClassNonPublic } from "../../structures/ClassNonPublic";
+
+export const test_notation_validateKebab_ClassNonPublic = (): void =>
+  _test_notation_validateGeneral("ClassNonPublic")<ClassNonPublic>(
+    ClassNonPublic,
+  )<typia.KebabCase<ClassNonPublic>>({
+    convert: (input) => typia.notations.validateKebab<ClassNonPublic>(input),
+    assert: typia.createAssert<typia.KebabCase<ClassNonPublic>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ClassPropertyAssignment.ts b/test/src/features/notation.kebab/test_notation_kebab_ClassPropertyAssignment.ts
new file mode 100644
index 0000000000..77a0ca48bd
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ClassPropertyAssignment.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ClassPropertyAssignment } from "../../structures/ClassPropertyAssignment";
+
+export const test_notation_validateKebab_ClassPropertyAssignment = (): void =>
+  _test_notation_validateGeneral(
+    "ClassPropertyAssignment",
+  )<ClassPropertyAssignment>(ClassPropertyAssignment)<
+    typia.KebabCase<ClassPropertyAssignment>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<ClassPropertyAssignment>(input),
+    assert: typia.createAssert<typia.KebabCase<ClassPropertyAssignment>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagArray.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagArray.ts
new file mode 100644
index 0000000000..72e267cf7b
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagArray.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagArray } from "../../structures/CommentTagArray";
+
+export const test_notation_validateKebab_CommentTagArray = (): void =>
+  _test_notation_validateGeneral("CommentTagArray")<CommentTagArray>(
+    CommentTagArray,
+  )<typia.KebabCase<CommentTagArray>>({
+    convert: (input) => typia.notations.validateKebab<CommentTagArray>(input),
+    assert: typia.createAssert<typia.KebabCase<CommentTagArray>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagArrayUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagArrayUnion.ts
new file mode 100644
index 0000000000..ab0ae78f82
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagArrayUnion.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagArrayUnion } from "../../structures/CommentTagArrayUnion";
+
+export const test_notation_validateKebab_CommentTagArrayUnion = (): void =>
+  _test_notation_validateGeneral("CommentTagArrayUnion")<CommentTagArrayUnion>(
+    CommentTagArrayUnion,
+  )<typia.KebabCase<CommentTagArrayUnion>>({
+    convert: (input) =>
+      typia.notations.validateKebab<CommentTagArrayUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<CommentTagArrayUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagAtomicUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagAtomicUnion.ts
new file mode 100644
index 0000000000..7d4450858b
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagAtomicUnion.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagAtomicUnion } from "../../structures/CommentTagAtomicUnion";
+
+export const test_notation_validateKebab_CommentTagAtomicUnion = (): void =>
+  _test_notation_validateGeneral(
+    "CommentTagAtomicUnion",
+  )<CommentTagAtomicUnion>(CommentTagAtomicUnion)<
+    typia.KebabCase<CommentTagAtomicUnion>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<CommentTagAtomicUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<CommentTagAtomicUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagBigInt.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagBigInt.ts
new file mode 100644
index 0000000000..48d4e352d4
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagBigInt.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagBigInt } from "../../structures/CommentTagBigInt";
+
+export const test_notation_validateKebab_CommentTagBigInt = (): void =>
+  _test_notation_validateGeneral("CommentTagBigInt")<CommentTagBigInt>(
+    CommentTagBigInt,
+  )<typia.KebabCase<CommentTagBigInt>>({
+    convert: (input) => typia.notations.validateKebab<CommentTagBigInt>(input),
+    assert: typia.createAssert<typia.KebabCase<CommentTagBigInt>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagDefault.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagDefault.ts
new file mode 100644
index 0000000000..019eac0eb2
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagDefault.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagDefault } from "../../structures/CommentTagDefault";
+
+export const test_notation_validateKebab_CommentTagDefault = (): void =>
+  _test_notation_validateGeneral("CommentTagDefault")<CommentTagDefault>(
+    CommentTagDefault,
+  )<typia.KebabCase<CommentTagDefault>>({
+    convert: (input) => typia.notations.validateKebab<CommentTagDefault>(input),
+    assert: typia.createAssert<typia.KebabCase<CommentTagDefault>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagFormat.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagFormat.ts
new file mode 100644
index 0000000000..10e36d9a26
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagFormat.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagFormat } from "../../structures/CommentTagFormat";
+
+export const test_notation_validateKebab_CommentTagFormat = (): void =>
+  _test_notation_validateGeneral("CommentTagFormat")<CommentTagFormat>(
+    CommentTagFormat,
+  )<typia.KebabCase<CommentTagFormat>>({
+    convert: (input) => typia.notations.validateKebab<CommentTagFormat>(input),
+    assert: typia.createAssert<typia.KebabCase<CommentTagFormat>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagInfinite.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagInfinite.ts
new file mode 100644
index 0000000000..450af73bce
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagInfinite.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagInfinite } from "../../structures/CommentTagInfinite";
+
+export const test_notation_validateKebab_CommentTagInfinite = (): void =>
+  _test_notation_validateGeneral("CommentTagInfinite")<CommentTagInfinite>(
+    CommentTagInfinite,
+  )<typia.KebabCase<CommentTagInfinite>>({
+    convert: (input) =>
+      typia.notations.validateKebab<CommentTagInfinite>(input),
+    assert: typia.createAssert<typia.KebabCase<CommentTagInfinite>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagLength.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagLength.ts
new file mode 100644
index 0000000000..d2fcf5b46f
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagLength.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagLength } from "../../structures/CommentTagLength";
+
+export const test_notation_validateKebab_CommentTagLength = (): void =>
+  _test_notation_validateGeneral("CommentTagLength")<CommentTagLength>(
+    CommentTagLength,
+  )<typia.KebabCase<CommentTagLength>>({
+    convert: (input) => typia.notations.validateKebab<CommentTagLength>(input),
+    assert: typia.createAssert<typia.KebabCase<CommentTagLength>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagNaN.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagNaN.ts
new file mode 100644
index 0000000000..7c44db616b
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagNaN.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagNaN } from "../../structures/CommentTagNaN";
+
+export const test_notation_validateKebab_CommentTagNaN = (): void =>
+  _test_notation_validateGeneral("CommentTagNaN")<CommentTagNaN>(CommentTagNaN)<
+    typia.KebabCase<CommentTagNaN>
+  >({
+    convert: (input) => typia.notations.validateKebab<CommentTagNaN>(input),
+    assert: typia.createAssert<typia.KebabCase<CommentTagNaN>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagObjectUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagObjectUnion.ts
new file mode 100644
index 0000000000..49b66a7052
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagObjectUnion.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagObjectUnion } from "../../structures/CommentTagObjectUnion";
+
+export const test_notation_validateKebab_CommentTagObjectUnion = (): void =>
+  _test_notation_validateGeneral(
+    "CommentTagObjectUnion",
+  )<CommentTagObjectUnion>(CommentTagObjectUnion)<
+    typia.KebabCase<CommentTagObjectUnion>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<CommentTagObjectUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<CommentTagObjectUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagPattern.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagPattern.ts
new file mode 100644
index 0000000000..0d6cd6750e
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagPattern.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagPattern } from "../../structures/CommentTagPattern";
+
+export const test_notation_validateKebab_CommentTagPattern = (): void =>
+  _test_notation_validateGeneral("CommentTagPattern")<CommentTagPattern>(
+    CommentTagPattern,
+  )<typia.KebabCase<CommentTagPattern>>({
+    convert: (input) => typia.notations.validateKebab<CommentTagPattern>(input),
+    assert: typia.createAssert<typia.KebabCase<CommentTagPattern>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagRange.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagRange.ts
new file mode 100644
index 0000000000..3e98f066b5
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagRange.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagRange } from "../../structures/CommentTagRange";
+
+export const test_notation_validateKebab_CommentTagRange = (): void =>
+  _test_notation_validateGeneral("CommentTagRange")<CommentTagRange>(
+    CommentTagRange,
+  )<typia.KebabCase<CommentTagRange>>({
+    convert: (input) => typia.notations.validateKebab<CommentTagRange>(input),
+    assert: typia.createAssert<typia.KebabCase<CommentTagRange>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagRangeBigInt.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagRangeBigInt.ts
new file mode 100644
index 0000000000..cec667bb9a
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagRangeBigInt.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagRangeBigInt } from "../../structures/CommentTagRangeBigInt";
+
+export const test_notation_validateKebab_CommentTagRangeBigInt = (): void =>
+  _test_notation_validateGeneral(
+    "CommentTagRangeBigInt",
+  )<CommentTagRangeBigInt>(CommentTagRangeBigInt)<
+    typia.KebabCase<CommentTagRangeBigInt>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<CommentTagRangeBigInt>(input),
+    assert: typia.createAssert<typia.KebabCase<CommentTagRangeBigInt>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagType.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagType.ts
new file mode 100644
index 0000000000..e096621e2a
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagType.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagType } from "../../structures/CommentTagType";
+
+export const test_notation_validateKebab_CommentTagType = (): void =>
+  _test_notation_validateGeneral("CommentTagType")<CommentTagType>(
+    CommentTagType,
+  )<typia.KebabCase<CommentTagType>>({
+    convert: (input) => typia.notations.validateKebab<CommentTagType>(input),
+    assert: typia.createAssert<typia.KebabCase<CommentTagType>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_CommentTagTypeBigInt.ts b/test/src/features/notation.kebab/test_notation_kebab_CommentTagTypeBigInt.ts
new file mode 100644
index 0000000000..79dcdfed9b
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_CommentTagTypeBigInt.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { CommentTagTypeBigInt } from "../../structures/CommentTagTypeBigInt";
+
+export const test_notation_validateKebab_CommentTagTypeBigInt = (): void =>
+  _test_notation_validateGeneral("CommentTagTypeBigInt")<CommentTagTypeBigInt>(
+    CommentTagTypeBigInt,
+  )<typia.KebabCase<CommentTagTypeBigInt>>({
+    convert: (input) =>
+      typia.notations.validateKebab<CommentTagTypeBigInt>(input),
+    assert: typia.createAssert<typia.KebabCase<CommentTagTypeBigInt>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicAbsorbed.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicAbsorbed.ts
new file mode 100644
index 0000000000..431c38e612
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicAbsorbed.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantAtomicAbsorbed } from "../../structures/ConstantAtomicAbsorbed";
+
+export const test_notation_validateKebab_ConstantAtomicAbsorbed = (): void =>
+  _test_notation_validateGeneral(
+    "ConstantAtomicAbsorbed",
+  )<ConstantAtomicAbsorbed>(ConstantAtomicAbsorbed)<
+    typia.KebabCase<ConstantAtomicAbsorbed>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<ConstantAtomicAbsorbed>(input),
+    assert: typia.createAssert<typia.KebabCase<ConstantAtomicAbsorbed>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicSimple.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicSimple.ts
new file mode 100644
index 0000000000..8a24d6e123
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicSimple.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantAtomicSimple } from "../../structures/ConstantAtomicSimple";
+
+export const test_notation_validateKebab_ConstantAtomicSimple = (): void =>
+  _test_notation_validateGeneral("ConstantAtomicSimple")<ConstantAtomicSimple>(
+    ConstantAtomicSimple,
+  )<typia.KebabCase<ConstantAtomicSimple>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ConstantAtomicSimple>(input),
+    assert: typia.createAssert<typia.KebabCase<ConstantAtomicSimple>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicTagged.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicTagged.ts
new file mode 100644
index 0000000000..bb694b71b3
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicTagged.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantAtomicTagged } from "../../structures/ConstantAtomicTagged";
+
+export const test_notation_validateKebab_ConstantAtomicTagged = (): void =>
+  _test_notation_validateGeneral("ConstantAtomicTagged")<ConstantAtomicTagged>(
+    ConstantAtomicTagged,
+  )<typia.KebabCase<ConstantAtomicTagged>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ConstantAtomicTagged>(input),
+    assert: typia.createAssert<typia.KebabCase<ConstantAtomicTagged>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicUnion.ts
new file mode 100644
index 0000000000..96b0405108
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicUnion.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantAtomicUnion } from "../../structures/ConstantAtomicUnion";
+
+export const test_notation_validateKebab_ConstantAtomicUnion = (): void =>
+  _test_notation_validateGeneral("ConstantAtomicUnion")<ConstantAtomicUnion>(
+    ConstantAtomicUnion,
+  )<typia.KebabCase<ConstantAtomicUnion>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ConstantAtomicUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<ConstantAtomicUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicWrapper.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicWrapper.ts
new file mode 100644
index 0000000000..12103a6487
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantAtomicWrapper.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantAtomicWrapper } from "../../structures/ConstantAtomicWrapper";
+
+export const test_notation_validateKebab_ConstantAtomicWrapper = (): void =>
+  _test_notation_validateGeneral(
+    "ConstantAtomicWrapper",
+  )<ConstantAtomicWrapper>(ConstantAtomicWrapper)<
+    typia.KebabCase<ConstantAtomicWrapper>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<ConstantAtomicWrapper>(input),
+    assert: typia.createAssert<typia.KebabCase<ConstantAtomicWrapper>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantConstEnumeration.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantConstEnumeration.ts
new file mode 100644
index 0000000000..d4d84d53fa
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantConstEnumeration.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantConstEnumeration } from "../../structures/ConstantConstEnumeration";
+
+export const test_notation_validateKebab_ConstantConstEnumeration = (): void =>
+  _test_notation_validateGeneral(
+    "ConstantConstEnumeration",
+  )<ConstantConstEnumeration>(ConstantConstEnumeration)<
+    typia.KebabCase<ConstantConstEnumeration>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<ConstantConstEnumeration>(input),
+    assert: typia.createAssert<typia.KebabCase<ConstantConstEnumeration>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantEnumeration.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantEnumeration.ts
new file mode 100644
index 0000000000..9dc3efa7b0
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantEnumeration.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantEnumeration } from "../../structures/ConstantEnumeration";
+
+export const test_notation_validateKebab_ConstantEnumeration = (): void =>
+  _test_notation_validateGeneral("ConstantEnumeration")<ConstantEnumeration>(
+    ConstantEnumeration,
+  )<typia.KebabCase<ConstantEnumeration>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ConstantEnumeration>(input),
+    assert: typia.createAssert<typia.KebabCase<ConstantEnumeration>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ConstantIntersection.ts b/test/src/features/notation.kebab/test_notation_kebab_ConstantIntersection.ts
new file mode 100644
index 0000000000..345df50eb1
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ConstantIntersection.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ConstantIntersection } from "../../structures/ConstantIntersection";
+
+export const test_notation_validateKebab_ConstantIntersection = (): void =>
+  _test_notation_validateGeneral("ConstantIntersection")<ConstantIntersection>(
+    ConstantIntersection,
+  )<typia.KebabCase<ConstantIntersection>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ConstantIntersection>(input),
+    assert: typia.createAssert<typia.KebabCase<ConstantIntersection>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_InstanceUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_InstanceUnion.ts
new file mode 100644
index 0000000000..dc33a21b65
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_InstanceUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { InstanceUnion } from "../../structures/InstanceUnion";
+
+export const test_notation_validateKebab_InstanceUnion = (): void =>
+  _test_notation_validateGeneral("InstanceUnion")<InstanceUnion>(InstanceUnion)<
+    typia.KebabCase<InstanceUnion>
+  >({
+    convert: (input) => typia.notations.validateKebab<InstanceUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<InstanceUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_MapAlias.ts b/test/src/features/notation.kebab/test_notation_kebab_MapAlias.ts
new file mode 100644
index 0000000000..21defce26c
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_MapAlias.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { MapAlias } from "../../structures/MapAlias";
+
+export const test_notation_validateKebab_MapAlias = (): void =>
+  _test_notation_validateGeneral("MapAlias")<MapAlias>(MapAlias)<
+    typia.KebabCase<MapAlias>
+  >({
+    convert: (input) => typia.notations.validateKebab<MapAlias>(input),
+    assert: typia.createAssert<typia.KebabCase<MapAlias>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_MapSimple.ts b/test/src/features/notation.kebab/test_notation_kebab_MapSimple.ts
new file mode 100644
index 0000000000..2535759bbe
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_MapSimple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { MapSimple } from "../../structures/MapSimple";
+
+export const test_notation_validateKebab_MapSimple = (): void =>
+  _test_notation_validateGeneral("MapSimple")<MapSimple>(MapSimple)<
+    typia.KebabCase<MapSimple>
+  >({
+    convert: (input) => typia.notations.validateKebab<MapSimple>(input),
+    assert: typia.createAssert<typia.KebabCase<MapSimple>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobuf.ts b/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobuf.ts
new file mode 100644
index 0000000000..13ee226e02
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobuf.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { MapSimpleProtobuf } from "../../structures/MapSimpleProtobuf";
+
+export const test_notation_validateKebab_MapSimpleProtobuf = (): void =>
+  _test_notation_validateGeneral("MapSimpleProtobuf")<MapSimpleProtobuf>(
+    MapSimpleProtobuf,
+  )<typia.KebabCase<MapSimpleProtobuf>>({
+    convert: (input) => typia.notations.validateKebab<MapSimpleProtobuf>(input),
+    assert: typia.createAssert<typia.KebabCase<MapSimpleProtobuf>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobufNullable.ts b/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobufNullable.ts
new file mode 100644
index 0000000000..2ac3bbd602
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobufNullable.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { MapSimpleProtobufNullable } from "../../structures/MapSimpleProtobufNullable";
+
+export const test_notation_validateKebab_MapSimpleProtobufNullable = (): void =>
+  _test_notation_validateGeneral(
+    "MapSimpleProtobufNullable",
+  )<MapSimpleProtobufNullable>(MapSimpleProtobufNullable)<
+    typia.KebabCase<MapSimpleProtobufNullable>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<MapSimpleProtobufNullable>(input),
+    assert: typia.createAssert<typia.KebabCase<MapSimpleProtobufNullable>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobufOptional.ts b/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobufOptional.ts
new file mode 100644
index 0000000000..e92581e7b1
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_MapSimpleProtobufOptional.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { MapSimpleProtobufOptional } from "../../structures/MapSimpleProtobufOptional";
+
+export const test_notation_validateKebab_MapSimpleProtobufOptional = (): void =>
+  _test_notation_validateGeneral(
+    "MapSimpleProtobufOptional",
+  )<MapSimpleProtobufOptional>(MapSimpleProtobufOptional)<
+    typia.KebabCase<MapSimpleProtobufOptional>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<MapSimpleProtobufOptional>(input),
+    assert: typia.createAssert<typia.KebabCase<MapSimpleProtobufOptional>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_MapUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_MapUnion.ts
new file mode 100644
index 0000000000..35be8b7fdc
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_MapUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { MapUnion } from "../../structures/MapUnion";
+
+export const test_notation_validateKebab_MapUnion = (): void =>
+  _test_notation_validateGeneral("MapUnion")<MapUnion>(MapUnion)<
+    typia.KebabCase<MapUnion>
+  >({
+    convert: (input) => typia.notations.validateKebab<MapUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<MapUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_NativeSimple.ts b/test/src/features/notation.kebab/test_notation_kebab_NativeSimple.ts
new file mode 100644
index 0000000000..2edaf6c56d
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_NativeSimple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { NativeSimple } from "../../structures/NativeSimple";
+
+export const test_notation_validateKebab_NativeSimple = (): void =>
+  _test_notation_validateGeneral("NativeSimple")<NativeSimple>(NativeSimple)<
+    typia.KebabCase<NativeSimple>
+  >({
+    convert: (input) => typia.notations.validateKebab<NativeSimple>(input),
+    assert: typia.createAssert<typia.KebabCase<NativeSimple>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_NativeUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_NativeUnion.ts
new file mode 100644
index 0000000000..697dc2024b
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_NativeUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { NativeUnion } from "../../structures/NativeUnion";
+
+export const test_notation_validateKebab_NativeUnion = (): void =>
+  _test_notation_validateGeneral("NativeUnion")<NativeUnion>(NativeUnion)<
+    typia.KebabCase<NativeUnion>
+  >({
+    convert: (input) => typia.notations.validateKebab<NativeUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<NativeUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectAlias.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectAlias.ts
new file mode 100644
index 0000000000..66325ff1fe
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectAlias.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectAlias } from "../../structures/ObjectAlias";
+
+export const test_notation_validateKebab_ObjectAlias = (): void =>
+  _test_notation_validateGeneral("ObjectAlias")<ObjectAlias>(ObjectAlias)<
+    typia.KebabCase<ObjectAlias>
+  >({
+    convert: (input) => typia.notations.validateKebab<ObjectAlias>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectAlias>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectDate.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectDate.ts
new file mode 100644
index 0000000000..e07b1b22c0
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectDate.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectDate } from "../../structures/ObjectDate";
+
+export const test_notation_validateKebab_ObjectDate = (): void =>
+  _test_notation_validateGeneral("ObjectDate")<ObjectDate>(ObjectDate)<
+    typia.KebabCase<ObjectDate>
+  >({
+    convert: (input) => typia.notations.validateKebab<ObjectDate>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectDate>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectDescription.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectDescription.ts
new file mode 100644
index 0000000000..d72169d72f
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectDescription.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectDescription } from "../../structures/ObjectDescription";
+
+export const test_notation_validateKebab_ObjectDescription = (): void =>
+  _test_notation_validateGeneral("ObjectDescription")<ObjectDescription>(
+    ObjectDescription,
+  )<typia.KebabCase<ObjectDescription>>({
+    convert: (input) => typia.notations.validateKebab<ObjectDescription>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectDescription>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectDynamic.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectDynamic.ts
new file mode 100644
index 0000000000..8719165fec
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectDynamic.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectDynamic } from "../../structures/ObjectDynamic";
+
+export const test_notation_validateKebab_ObjectDynamic = (): void =>
+  _test_notation_validateGeneral("ObjectDynamic")<ObjectDynamic>(ObjectDynamic)<
+    typia.KebabCase<ObjectDynamic>
+  >({
+    convert: (input) => typia.notations.validateKebab<ObjectDynamic>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectDynamic>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectGeneric.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectGeneric.ts
new file mode 100644
index 0000000000..11fc7bbc5d
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectGeneric.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectGeneric } from "../../structures/ObjectGeneric";
+
+export const test_notation_validateKebab_ObjectGeneric = (): void =>
+  _test_notation_validateGeneral("ObjectGeneric")<ObjectGeneric>(ObjectGeneric)<
+    typia.KebabCase<ObjectGeneric>
+  >({
+    convert: (input) => typia.notations.validateKebab<ObjectGeneric>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectGeneric>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericAlias.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericAlias.ts
new file mode 100644
index 0000000000..b198a53b35
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericAlias.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectGenericAlias } from "../../structures/ObjectGenericAlias";
+
+export const test_notation_validateKebab_ObjectGenericAlias = (): void =>
+  _test_notation_validateGeneral("ObjectGenericAlias")<ObjectGenericAlias>(
+    ObjectGenericAlias,
+  )<typia.KebabCase<ObjectGenericAlias>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectGenericAlias>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectGenericAlias>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericArray.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericArray.ts
new file mode 100644
index 0000000000..c060a94534
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericArray.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectGenericArray } from "../../structures/ObjectGenericArray";
+
+export const test_notation_validateKebab_ObjectGenericArray = (): void =>
+  _test_notation_validateGeneral("ObjectGenericArray")<ObjectGenericArray>(
+    ObjectGenericArray,
+  )<typia.KebabCase<ObjectGenericArray>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectGenericArray>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectGenericArray>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericUnion.ts
new file mode 100644
index 0000000000..a07387ff48
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectGenericUnion.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectGenericUnion } from "../../structures/ObjectGenericUnion";
+
+export const test_notation_validateKebab_ObjectGenericUnion = (): void =>
+  _test_notation_validateGeneral("ObjectGenericUnion")<ObjectGenericUnion>(
+    ObjectGenericUnion,
+  )<typia.KebabCase<ObjectGenericUnion>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectGenericUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectGenericUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHierarchical.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHierarchical.ts
new file mode 100644
index 0000000000..749a983815
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHierarchical.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHierarchical } from "../../structures/ObjectHierarchical";
+
+export const test_notation_validateKebab_ObjectHierarchical = (): void =>
+  _test_notation_validateGeneral("ObjectHierarchical")<ObjectHierarchical>(
+    ObjectHierarchical,
+  )<typia.KebabCase<ObjectHierarchical>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectHierarchical>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectHierarchical>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpArray.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpArray.ts
new file mode 100644
index 0000000000..50d5c60733
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpArray.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpArray } from "../../structures/ObjectHttpArray";
+
+export const test_notation_validateKebab_ObjectHttpArray = (): void =>
+  _test_notation_validateGeneral("ObjectHttpArray")<ObjectHttpArray>(
+    ObjectHttpArray,
+  )<typia.KebabCase<ObjectHttpArray>>({
+    convert: (input) => typia.notations.validateKebab<ObjectHttpArray>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectHttpArray>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpAtomic.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpAtomic.ts
new file mode 100644
index 0000000000..62f16830fb
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpAtomic.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpAtomic } from "../../structures/ObjectHttpAtomic";
+
+export const test_notation_validateKebab_ObjectHttpAtomic = (): void =>
+  _test_notation_validateGeneral("ObjectHttpAtomic")<ObjectHttpAtomic>(
+    ObjectHttpAtomic,
+  )<typia.KebabCase<ObjectHttpAtomic>>({
+    convert: (input) => typia.notations.validateKebab<ObjectHttpAtomic>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectHttpAtomic>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpCommentTag.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpCommentTag.ts
new file mode 100644
index 0000000000..829d35c048
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpCommentTag.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpCommentTag } from "../../structures/ObjectHttpCommentTag";
+
+export const test_notation_validateKebab_ObjectHttpCommentTag = (): void =>
+  _test_notation_validateGeneral("ObjectHttpCommentTag")<ObjectHttpCommentTag>(
+    ObjectHttpCommentTag,
+  )<typia.KebabCase<ObjectHttpCommentTag>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectHttpCommentTag>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectHttpCommentTag>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpConstant.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpConstant.ts
new file mode 100644
index 0000000000..8365bcb236
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpConstant.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpConstant } from "../../structures/ObjectHttpConstant";
+
+export const test_notation_validateKebab_ObjectHttpConstant = (): void =>
+  _test_notation_validateGeneral("ObjectHttpConstant")<ObjectHttpConstant>(
+    ObjectHttpConstant,
+  )<typia.KebabCase<ObjectHttpConstant>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectHttpConstant>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectHttpConstant>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpFormData.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpFormData.ts
new file mode 100644
index 0000000000..7ee2bbbdaf
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpFormData.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpFormData } from "../../structures/ObjectHttpFormData";
+
+export const test_notation_validateKebab_ObjectHttpFormData = (): void =>
+  _test_notation_validateGeneral("ObjectHttpFormData")<ObjectHttpFormData>(
+    ObjectHttpFormData,
+  )<typia.KebabCase<ObjectHttpFormData>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectHttpFormData>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectHttpFormData>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpNullable.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpNullable.ts
new file mode 100644
index 0000000000..f9da0f6951
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpNullable.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpNullable } from "../../structures/ObjectHttpNullable";
+
+export const test_notation_validateKebab_ObjectHttpNullable = (): void =>
+  _test_notation_validateGeneral("ObjectHttpNullable")<ObjectHttpNullable>(
+    ObjectHttpNullable,
+  )<typia.KebabCase<ObjectHttpNullable>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectHttpNullable>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectHttpNullable>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpTypeTag.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpTypeTag.ts
new file mode 100644
index 0000000000..b57d03085e
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpTypeTag.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpTypeTag } from "../../structures/ObjectHttpTypeTag";
+
+export const test_notation_validateKebab_ObjectHttpTypeTag = (): void =>
+  _test_notation_validateGeneral("ObjectHttpTypeTag")<ObjectHttpTypeTag>(
+    ObjectHttpTypeTag,
+  )<typia.KebabCase<ObjectHttpTypeTag>>({
+    convert: (input) => typia.notations.validateKebab<ObjectHttpTypeTag>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectHttpTypeTag>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpUndefindable.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpUndefindable.ts
new file mode 100644
index 0000000000..7965126e5d
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectHttpUndefindable.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectHttpUndefindable } from "../../structures/ObjectHttpUndefindable";
+
+export const test_notation_validateKebab_ObjectHttpUndefindable = (): void =>
+  _test_notation_validateGeneral(
+    "ObjectHttpUndefindable",
+  )<ObjectHttpUndefindable>(ObjectHttpUndefindable)<
+    typia.KebabCase<ObjectHttpUndefindable>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectHttpUndefindable>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectHttpUndefindable>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectIntersection.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectIntersection.ts
new file mode 100644
index 0000000000..ebc0c68a4a
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectIntersection.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectIntersection } from "../../structures/ObjectIntersection";
+
+export const test_notation_validateKebab_ObjectIntersection = (): void =>
+  _test_notation_validateGeneral("ObjectIntersection")<ObjectIntersection>(
+    ObjectIntersection,
+  )<typia.KebabCase<ObjectIntersection>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectIntersection>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectIntersection>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectJsonTag.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectJsonTag.ts
new file mode 100644
index 0000000000..49f73c549e
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectJsonTag.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectJsonTag } from "../../structures/ObjectJsonTag";
+
+export const test_notation_validateKebab_ObjectJsonTag = (): void =>
+  _test_notation_validateGeneral("ObjectJsonTag")<ObjectJsonTag>(ObjectJsonTag)<
+    typia.KebabCase<ObjectJsonTag>
+  >({
+    convert: (input) => typia.notations.validateKebab<ObjectJsonTag>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectJsonTag>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectLiteralProperty.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectLiteralProperty.ts
new file mode 100644
index 0000000000..7bdacc7e57
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectLiteralProperty.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectLiteralProperty } from "../../structures/ObjectLiteralProperty";
+
+export const test_notation_validateKebab_ObjectLiteralProperty = (): void =>
+  _test_notation_validateGeneral(
+    "ObjectLiteralProperty",
+  )<ObjectLiteralProperty>(ObjectLiteralProperty)<
+    typia.KebabCase<ObjectLiteralProperty>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectLiteralProperty>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectLiteralProperty>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectLiteralType.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectLiteralType.ts
new file mode 100644
index 0000000000..f5b946ee24
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectLiteralType.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectLiteralType } from "../../structures/ObjectLiteralType";
+
+export const test_notation_validateKebab_ObjectLiteralType = (): void =>
+  _test_notation_validateGeneral("ObjectLiteralType")<ObjectLiteralType>(
+    ObjectLiteralType,
+  )<typia.KebabCase<ObjectLiteralType>>({
+    convert: (input) => typia.notations.validateKebab<ObjectLiteralType>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectLiteralType>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectNullable.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectNullable.ts
new file mode 100644
index 0000000000..f4d57e3ddd
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectNullable.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectNullable } from "../../structures/ObjectNullable";
+
+export const test_notation_validateKebab_ObjectNullable = (): void =>
+  _test_notation_validateGeneral("ObjectNullable")<ObjectNullable>(
+    ObjectNullable,
+  )<typia.KebabCase<ObjectNullable>>({
+    convert: (input) => typia.notations.validateKebab<ObjectNullable>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectNullable>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectOptional.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectOptional.ts
new file mode 100644
index 0000000000..46c22a2b47
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectOptional.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectOptional } from "../../structures/ObjectOptional";
+
+export const test_notation_validateKebab_ObjectOptional = (): void =>
+  _test_notation_validateGeneral("ObjectOptional")<ObjectOptional>(
+    ObjectOptional,
+  )<typia.KebabCase<ObjectOptional>>({
+    convert: (input) => typia.notations.validateKebab<ObjectOptional>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectOptional>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectPartial.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectPartial.ts
new file mode 100644
index 0000000000..c633c9f099
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectPartial.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectPartial } from "../../structures/ObjectPartial";
+
+export const test_notation_validateKebab_ObjectPartial = (): void =>
+  _test_notation_validateGeneral("ObjectPartial")<ObjectPartial>(ObjectPartial)<
+    typia.KebabCase<ObjectPartial>
+  >({
+    convert: (input) => typia.notations.validateKebab<ObjectPartial>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectPartial>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectPartialAndRequired.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectPartialAndRequired.ts
new file mode 100644
index 0000000000..24a95202ff
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectPartialAndRequired.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectPartialAndRequired } from "../../structures/ObjectPartialAndRequired";
+
+export const test_notation_validateKebab_ObjectPartialAndRequired = (): void =>
+  _test_notation_validateGeneral(
+    "ObjectPartialAndRequired",
+  )<ObjectPartialAndRequired>(ObjectPartialAndRequired)<
+    typia.KebabCase<ObjectPartialAndRequired>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectPartialAndRequired>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectPartialAndRequired>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectPrimitive.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectPrimitive.ts
new file mode 100644
index 0000000000..4605ff0248
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectPrimitive.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectPrimitive } from "../../structures/ObjectPrimitive";
+
+export const test_notation_validateKebab_ObjectPrimitive = (): void =>
+  _test_notation_validateGeneral("ObjectPrimitive")<ObjectPrimitive>(
+    ObjectPrimitive,
+  )<typia.KebabCase<ObjectPrimitive>>({
+    convert: (input) => typia.notations.validateKebab<ObjectPrimitive>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectPrimitive>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectPropertyNullable.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectPropertyNullable.ts
new file mode 100644
index 0000000000..79a27daecc
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectPropertyNullable.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectPropertyNullable } from "../../structures/ObjectPropertyNullable";
+
+export const test_notation_validateKebab_ObjectPropertyNullable = (): void =>
+  _test_notation_validateGeneral(
+    "ObjectPropertyNullable",
+  )<ObjectPropertyNullable>(ObjectPropertyNullable)<
+    typia.KebabCase<ObjectPropertyNullable>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectPropertyNullable>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectPropertyNullable>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectRecursive.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectRecursive.ts
new file mode 100644
index 0000000000..d8d7487a06
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectRecursive.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectRecursive } from "../../structures/ObjectRecursive";
+
+export const test_notation_validateKebab_ObjectRecursive = (): void =>
+  _test_notation_validateGeneral("ObjectRecursive")<ObjectRecursive>(
+    ObjectRecursive,
+  )<typia.KebabCase<ObjectRecursive>>({
+    convert: (input) => typia.notations.validateKebab<ObjectRecursive>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectRecursive>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectRequired.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectRequired.ts
new file mode 100644
index 0000000000..3cc04a4d06
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectRequired.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectRequired } from "../../structures/ObjectRequired";
+
+export const test_notation_validateKebab_ObjectRequired = (): void =>
+  _test_notation_validateGeneral("ObjectRequired")<ObjectRequired>(
+    ObjectRequired,
+  )<typia.KebabCase<ObjectRequired>>({
+    convert: (input) => typia.notations.validateKebab<ObjectRequired>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectRequired>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectSequenceProtobuf.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectSequenceProtobuf.ts
new file mode 100644
index 0000000000..bd902d7b2f
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectSequenceProtobuf.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectSequenceProtobuf } from "../../structures/ObjectSequenceProtobuf";
+
+export const test_notation_validateKebab_ObjectSequenceProtobuf = (): void =>
+  _test_notation_validateGeneral(
+    "ObjectSequenceProtobuf",
+  )<ObjectSequenceProtobuf>(ObjectSequenceProtobuf)<
+    typia.KebabCase<ObjectSequenceProtobuf>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectSequenceProtobuf>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectSequenceProtobuf>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectSimple.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimple.ts
new file mode 100644
index 0000000000..a4141df806
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectSimple } from "../../structures/ObjectSimple";
+
+export const test_notation_validateKebab_ObjectSimple = (): void =>
+  _test_notation_validateGeneral("ObjectSimple")<ObjectSimple>(ObjectSimple)<
+    typia.KebabCase<ObjectSimple>
+  >({
+    convert: (input) => typia.notations.validateKebab<ObjectSimple>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectSimple>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobuf.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobuf.ts
new file mode 100644
index 0000000000..234621ada8
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobuf.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectSimpleProtobuf } from "../../structures/ObjectSimpleProtobuf";
+
+export const test_notation_validateKebab_ObjectSimpleProtobuf = (): void =>
+  _test_notation_validateGeneral("ObjectSimpleProtobuf")<ObjectSimpleProtobuf>(
+    ObjectSimpleProtobuf,
+  )<typia.KebabCase<ObjectSimpleProtobuf>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectSimpleProtobuf>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectSimpleProtobuf>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobufNullable.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobufNullable.ts
new file mode 100644
index 0000000000..df42a7f4ca
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobufNullable.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectSimpleProtobufNullable } from "../../structures/ObjectSimpleProtobufNullable";
+
+export const test_notation_validateKebab_ObjectSimpleProtobufNullable =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectSimpleProtobufNullable",
+    )<ObjectSimpleProtobufNullable>(ObjectSimpleProtobufNullable)<
+      typia.KebabCase<ObjectSimpleProtobufNullable>
+    >({
+      convert: (input) =>
+        typia.notations.validateKebab<ObjectSimpleProtobufNullable>(input),
+      assert:
+        typia.createAssert<typia.KebabCase<ObjectSimpleProtobufNullable>>(),
+    });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobufOptional.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobufOptional.ts
new file mode 100644
index 0000000000..07989843a5
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectSimpleProtobufOptional.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectSimpleProtobufOptional } from "../../structures/ObjectSimpleProtobufOptional";
+
+export const test_notation_validateKebab_ObjectSimpleProtobufOptional =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectSimpleProtobufOptional",
+    )<ObjectSimpleProtobufOptional>(ObjectSimpleProtobufOptional)<
+      typia.KebabCase<ObjectSimpleProtobufOptional>
+    >({
+      convert: (input) =>
+        typia.notations.validateKebab<ObjectSimpleProtobufOptional>(input),
+      assert:
+        typia.createAssert<typia.KebabCase<ObjectSimpleProtobufOptional>>(),
+    });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectTuple.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectTuple.ts
new file mode 100644
index 0000000000..3a27c0dc0a
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectTuple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectTuple } from "../../structures/ObjectTuple";
+
+export const test_notation_validateKebab_ObjectTuple = (): void =>
+  _test_notation_validateGeneral("ObjectTuple")<ObjectTuple>(ObjectTuple)<
+    typia.KebabCase<ObjectTuple>
+  >({
+    convert: (input) => typia.notations.validateKebab<ObjectTuple>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectTuple>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUndefined.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUndefined.ts
new file mode 100644
index 0000000000..f69df9ef02
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUndefined.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUndefined } from "../../structures/ObjectUndefined";
+
+export const test_notation_validateKebab_ObjectUndefined = (): void =>
+  _test_notation_validateGeneral("ObjectUndefined")<ObjectUndefined>(
+    ObjectUndefined,
+  )<typia.KebabCase<ObjectUndefined>>({
+    convert: (input) => typia.notations.validateKebab<ObjectUndefined>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectUndefined>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionComposite.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionComposite.ts
new file mode 100644
index 0000000000..3b2d2dbdf2
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionComposite.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUnionComposite } from "../../structures/ObjectUnionComposite";
+
+export const test_notation_validateKebab_ObjectUnionComposite = (): void =>
+  _test_notation_validateGeneral("ObjectUnionComposite")<ObjectUnionComposite>(
+    ObjectUnionComposite,
+  )<typia.KebabCase<ObjectUnionComposite>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectUnionComposite>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectUnionComposite>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionCompositePointer.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionCompositePointer.ts
new file mode 100644
index 0000000000..d6fc2ac387
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionCompositePointer.ts
@@ -0,0 +1,17 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUnionCompositePointer } from "../../structures/ObjectUnionCompositePointer";
+
+export const test_notation_validateKebab_ObjectUnionCompositePointer =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectUnionCompositePointer",
+    )<ObjectUnionCompositePointer>(ObjectUnionCompositePointer)<
+      typia.KebabCase<ObjectUnionCompositePointer>
+    >({
+      convert: (input) =>
+        typia.notations.validateKebab<ObjectUnionCompositePointer>(input),
+      assert:
+        typia.createAssert<typia.KebabCase<ObjectUnionCompositePointer>>(),
+    });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionDouble.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionDouble.ts
new file mode 100644
index 0000000000..29ab4460e1
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionDouble.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUnionDouble } from "../../structures/ObjectUnionDouble";
+
+export const test_notation_validateKebab_ObjectUnionDouble = (): void =>
+  _test_notation_validateGeneral("ObjectUnionDouble")<ObjectUnionDouble>(
+    ObjectUnionDouble,
+  )<typia.KebabCase<ObjectUnionDouble>>({
+    convert: (input) => typia.notations.validateKebab<ObjectUnionDouble>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectUnionDouble>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionExplicit.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionExplicit.ts
new file mode 100644
index 0000000000..a3410c5803
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionExplicit.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUnionExplicit } from "../../structures/ObjectUnionExplicit";
+
+export const test_notation_validateKebab_ObjectUnionExplicit = (): void =>
+  _test_notation_validateGeneral("ObjectUnionExplicit")<ObjectUnionExplicit>(
+    ObjectUnionExplicit,
+  )<typia.KebabCase<ObjectUnionExplicit>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectUnionExplicit>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectUnionExplicit>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionExplicitPointer.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionExplicitPointer.ts
new file mode 100644
index 0000000000..9b3f522020
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionExplicitPointer.ts
@@ -0,0 +1,16 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUnionExplicitPointer } from "../../structures/ObjectUnionExplicitPointer";
+
+export const test_notation_validateKebab_ObjectUnionExplicitPointer =
+  (): void =>
+    _test_notation_validateGeneral(
+      "ObjectUnionExplicitPointer",
+    )<ObjectUnionExplicitPointer>(ObjectUnionExplicitPointer)<
+      typia.KebabCase<ObjectUnionExplicitPointer>
+    >({
+      convert: (input) =>
+        typia.notations.validateKebab<ObjectUnionExplicitPointer>(input),
+      assert: typia.createAssert<typia.KebabCase<ObjectUnionExplicitPointer>>(),
+    });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionImplicit.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionImplicit.ts
new file mode 100644
index 0000000000..589dfd0801
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionImplicit.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUnionImplicit } from "../../structures/ObjectUnionImplicit";
+
+export const test_notation_validateKebab_ObjectUnionImplicit = (): void =>
+  _test_notation_validateGeneral("ObjectUnionImplicit")<ObjectUnionImplicit>(
+    ObjectUnionImplicit,
+  )<typia.KebabCase<ObjectUnionImplicit>>({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectUnionImplicit>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectUnionImplicit>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionNonPredictable.ts b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionNonPredictable.ts
new file mode 100644
index 0000000000..3de561ce88
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_ObjectUnionNonPredictable.ts
@@ -0,0 +1,15 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { ObjectUnionNonPredictable } from "../../structures/ObjectUnionNonPredictable";
+
+export const test_notation_validateKebab_ObjectUnionNonPredictable = (): void =>
+  _test_notation_validateGeneral(
+    "ObjectUnionNonPredictable",
+  )<ObjectUnionNonPredictable>(ObjectUnionNonPredictable)<
+    typia.KebabCase<ObjectUnionNonPredictable>
+  >({
+    convert: (input) =>
+      typia.notations.validateKebab<ObjectUnionNonPredictable>(input),
+    assert: typia.createAssert<typia.KebabCase<ObjectUnionNonPredictable>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_SetAlias.ts b/test/src/features/notation.kebab/test_notation_kebab_SetAlias.ts
new file mode 100644
index 0000000000..caa9aac84b
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_SetAlias.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { SetAlias } from "../../structures/SetAlias";
+
+export const test_notation_validateKebab_SetAlias = (): void =>
+  _test_notation_validateGeneral("SetAlias")<SetAlias>(SetAlias)<
+    typia.KebabCase<SetAlias>
+  >({
+    convert: (input) => typia.notations.validateKebab<SetAlias>(input),
+    assert: typia.createAssert<typia.KebabCase<SetAlias>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_SetSimple.ts b/test/src/features/notation.kebab/test_notation_kebab_SetSimple.ts
new file mode 100644
index 0000000000..0855bb3a8e
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_SetSimple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { SetSimple } from "../../structures/SetSimple";
+
+export const test_notation_validateKebab_SetSimple = (): void =>
+  _test_notation_validateGeneral("SetSimple")<SetSimple>(SetSimple)<
+    typia.KebabCase<SetSimple>
+  >({
+    convert: (input) => typia.notations.validateKebab<SetSimple>(input),
+    assert: typia.createAssert<typia.KebabCase<SetSimple>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_SetUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_SetUnion.ts
new file mode 100644
index 0000000000..163653abd4
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_SetUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { SetUnion } from "../../structures/SetUnion";
+
+export const test_notation_validateKebab_SetUnion = (): void =>
+  _test_notation_validateGeneral("SetUnion")<SetUnion>(SetUnion)<
+    typia.KebabCase<SetUnion>
+  >({
+    convert: (input) => typia.notations.validateKebab<SetUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<SetUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TemplateAtomic.ts b/test/src/features/notation.kebab/test_notation_kebab_TemplateAtomic.ts
new file mode 100644
index 0000000000..88890b8482
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TemplateAtomic.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TemplateAtomic } from "../../structures/TemplateAtomic";
+
+export const test_notation_validateKebab_TemplateAtomic = (): void =>
+  _test_notation_validateGeneral("TemplateAtomic")<TemplateAtomic>(
+    TemplateAtomic,
+  )<typia.KebabCase<TemplateAtomic>>({
+    convert: (input) => typia.notations.validateKebab<TemplateAtomic>(input),
+    assert: typia.createAssert<typia.KebabCase<TemplateAtomic>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TemplateConstant.ts b/test/src/features/notation.kebab/test_notation_kebab_TemplateConstant.ts
new file mode 100644
index 0000000000..49dc21e00c
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TemplateConstant.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TemplateConstant } from "../../structures/TemplateConstant";
+
+export const test_notation_validateKebab_TemplateConstant = (): void =>
+  _test_notation_validateGeneral("TemplateConstant")<TemplateConstant>(
+    TemplateConstant,
+  )<typia.KebabCase<TemplateConstant>>({
+    convert: (input) => typia.notations.validateKebab<TemplateConstant>(input),
+    assert: typia.createAssert<typia.KebabCase<TemplateConstant>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TemplateUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_TemplateUnion.ts
new file mode 100644
index 0000000000..1a97d918c4
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TemplateUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TemplateUnion } from "../../structures/TemplateUnion";
+
+export const test_notation_validateKebab_TemplateUnion = (): void =>
+  _test_notation_validateGeneral("TemplateUnion")<TemplateUnion>(TemplateUnion)<
+    typia.KebabCase<TemplateUnion>
+  >({
+    convert: (input) => typia.notations.validateKebab<TemplateUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<TemplateUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TupleHierarchical.ts b/test/src/features/notation.kebab/test_notation_kebab_TupleHierarchical.ts
new file mode 100644
index 0000000000..c70adfdc50
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TupleHierarchical.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TupleHierarchical } from "../../structures/TupleHierarchical";
+
+export const test_notation_validateKebab_TupleHierarchical = (): void =>
+  _test_notation_validateGeneral("TupleHierarchical")<TupleHierarchical>(
+    TupleHierarchical,
+  )<typia.KebabCase<TupleHierarchical>>({
+    convert: (input) => typia.notations.validateKebab<TupleHierarchical>(input),
+    assert: typia.createAssert<typia.KebabCase<TupleHierarchical>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TupleOptional.ts b/test/src/features/notation.kebab/test_notation_kebab_TupleOptional.ts
new file mode 100644
index 0000000000..f9bd194049
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TupleOptional.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TupleOptional } from "../../structures/TupleOptional";
+
+export const test_notation_validateKebab_TupleOptional = (): void =>
+  _test_notation_validateGeneral("TupleOptional")<TupleOptional>(TupleOptional)<
+    typia.KebabCase<TupleOptional>
+  >({
+    convert: (input) => typia.notations.validateKebab<TupleOptional>(input),
+    assert: typia.createAssert<typia.KebabCase<TupleOptional>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TupleRestArray.ts b/test/src/features/notation.kebab/test_notation_kebab_TupleRestArray.ts
new file mode 100644
index 0000000000..22dce23edc
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TupleRestArray.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TupleRestArray } from "../../structures/TupleRestArray";
+
+export const test_notation_validateKebab_TupleRestArray = (): void =>
+  _test_notation_validateGeneral("TupleRestArray")<TupleRestArray>(
+    TupleRestArray,
+  )<typia.KebabCase<TupleRestArray>>({
+    convert: (input) => typia.notations.validateKebab<TupleRestArray>(input),
+    assert: typia.createAssert<typia.KebabCase<TupleRestArray>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TupleRestAtomic.ts b/test/src/features/notation.kebab/test_notation_kebab_TupleRestAtomic.ts
new file mode 100644
index 0000000000..1c05cb5323
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TupleRestAtomic.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TupleRestAtomic } from "../../structures/TupleRestAtomic";
+
+export const test_notation_validateKebab_TupleRestAtomic = (): void =>
+  _test_notation_validateGeneral("TupleRestAtomic")<TupleRestAtomic>(
+    TupleRestAtomic,
+  )<typia.KebabCase<TupleRestAtomic>>({
+    convert: (input) => typia.notations.validateKebab<TupleRestAtomic>(input),
+    assert: typia.createAssert<typia.KebabCase<TupleRestAtomic>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TupleRestObject.ts b/test/src/features/notation.kebab/test_notation_kebab_TupleRestObject.ts
new file mode 100644
index 0000000000..673922463b
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TupleRestObject.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TupleRestObject } from "../../structures/TupleRestObject";
+
+export const test_notation_validateKebab_TupleRestObject = (): void =>
+  _test_notation_validateGeneral("TupleRestObject")<TupleRestObject>(
+    TupleRestObject,
+  )<typia.KebabCase<TupleRestObject>>({
+    convert: (input) => typia.notations.validateKebab<TupleRestObject>(input),
+    assert: typia.createAssert<typia.KebabCase<TupleRestObject>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TupleUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_TupleUnion.ts
new file mode 100644
index 0000000000..87e3e3912a
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TupleUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TupleUnion } from "../../structures/TupleUnion";
+
+export const test_notation_validateKebab_TupleUnion = (): void =>
+  _test_notation_validateGeneral("TupleUnion")<TupleUnion>(TupleUnion)<
+    typia.KebabCase<TupleUnion>
+  >({
+    convert: (input) => typia.notations.validateKebab<TupleUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<TupleUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagArray.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagArray.ts
new file mode 100644
index 0000000000..4daf112987
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagArray.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagArray } from "../../structures/TypeTagArray";
+
+export const test_notation_validateKebab_TypeTagArray = (): void =>
+  _test_notation_validateGeneral("TypeTagArray")<TypeTagArray>(TypeTagArray)<
+    typia.KebabCase<TypeTagArray>
+  >({
+    convert: (input) => typia.notations.validateKebab<TypeTagArray>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagArray>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagArrayUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagArrayUnion.ts
new file mode 100644
index 0000000000..461c4c91e6
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagArrayUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagArrayUnion } from "../../structures/TypeTagArrayUnion";
+
+export const test_notation_validateKebab_TypeTagArrayUnion = (): void =>
+  _test_notation_validateGeneral("TypeTagArrayUnion")<TypeTagArrayUnion>(
+    TypeTagArrayUnion,
+  )<typia.KebabCase<TypeTagArrayUnion>>({
+    convert: (input) => typia.notations.validateKebab<TypeTagArrayUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagArrayUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagAtomicUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagAtomicUnion.ts
new file mode 100644
index 0000000000..be4cbe9e95
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagAtomicUnion.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagAtomicUnion } from "../../structures/TypeTagAtomicUnion";
+
+export const test_notation_validateKebab_TypeTagAtomicUnion = (): void =>
+  _test_notation_validateGeneral("TypeTagAtomicUnion")<TypeTagAtomicUnion>(
+    TypeTagAtomicUnion,
+  )<typia.KebabCase<TypeTagAtomicUnion>>({
+    convert: (input) =>
+      typia.notations.validateKebab<TypeTagAtomicUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagAtomicUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagBigInt.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagBigInt.ts
new file mode 100644
index 0000000000..7db6873be0
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagBigInt.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagBigInt } from "../../structures/TypeTagBigInt";
+
+export const test_notation_validateKebab_TypeTagBigInt = (): void =>
+  _test_notation_validateGeneral("TypeTagBigInt")<TypeTagBigInt>(TypeTagBigInt)<
+    typia.KebabCase<TypeTagBigInt>
+  >({
+    convert: (input) => typia.notations.validateKebab<TypeTagBigInt>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagBigInt>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagCustom.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagCustom.ts
new file mode 100644
index 0000000000..8b7f202985
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagCustom.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagCustom } from "../../structures/TypeTagCustom";
+
+export const test_notation_validateKebab_TypeTagCustom = (): void =>
+  _test_notation_validateGeneral("TypeTagCustom")<TypeTagCustom>(TypeTagCustom)<
+    typia.KebabCase<TypeTagCustom>
+  >({
+    convert: (input) => typia.notations.validateKebab<TypeTagCustom>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagCustom>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagDefault.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagDefault.ts
new file mode 100644
index 0000000000..38958c2af9
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagDefault.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagDefault } from "../../structures/TypeTagDefault";
+
+export const test_notation_validateKebab_TypeTagDefault = (): void =>
+  _test_notation_validateGeneral("TypeTagDefault")<TypeTagDefault>(
+    TypeTagDefault,
+  )<typia.KebabCase<TypeTagDefault>>({
+    convert: (input) => typia.notations.validateKebab<TypeTagDefault>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagDefault>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagFormat.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagFormat.ts
new file mode 100644
index 0000000000..6ef8a69625
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagFormat.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagFormat } from "../../structures/TypeTagFormat";
+
+export const test_notation_validateKebab_TypeTagFormat = (): void =>
+  _test_notation_validateGeneral("TypeTagFormat")<TypeTagFormat>(TypeTagFormat)<
+    typia.KebabCase<TypeTagFormat>
+  >({
+    convert: (input) => typia.notations.validateKebab<TypeTagFormat>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagFormat>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagInfinite.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagInfinite.ts
new file mode 100644
index 0000000000..3b0f553f23
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagInfinite.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagInfinite } from "../../structures/TypeTagInfinite";
+
+export const test_notation_validateKebab_TypeTagInfinite = (): void =>
+  _test_notation_validateGeneral("TypeTagInfinite")<TypeTagInfinite>(
+    TypeTagInfinite,
+  )<typia.KebabCase<TypeTagInfinite>>({
+    convert: (input) => typia.notations.validateKebab<TypeTagInfinite>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagInfinite>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagLength.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagLength.ts
new file mode 100644
index 0000000000..15357bd5f5
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagLength.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagLength } from "../../structures/TypeTagLength";
+
+export const test_notation_validateKebab_TypeTagLength = (): void =>
+  _test_notation_validateGeneral("TypeTagLength")<TypeTagLength>(TypeTagLength)<
+    typia.KebabCase<TypeTagLength>
+  >({
+    convert: (input) => typia.notations.validateKebab<TypeTagLength>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagLength>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagMatrix.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagMatrix.ts
new file mode 100644
index 0000000000..9f2daa0c1b
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagMatrix.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagMatrix } from "../../structures/TypeTagMatrix";
+
+export const test_notation_validateKebab_TypeTagMatrix = (): void =>
+  _test_notation_validateGeneral("TypeTagMatrix")<TypeTagMatrix>(TypeTagMatrix)<
+    typia.KebabCase<TypeTagMatrix>
+  >({
+    convert: (input) => typia.notations.validateKebab<TypeTagMatrix>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagMatrix>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagNaN.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagNaN.ts
new file mode 100644
index 0000000000..423cc89769
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagNaN.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagNaN } from "../../structures/TypeTagNaN";
+
+export const test_notation_validateKebab_TypeTagNaN = (): void =>
+  _test_notation_validateGeneral("TypeTagNaN")<TypeTagNaN>(TypeTagNaN)<
+    typia.KebabCase<TypeTagNaN>
+  >({
+    convert: (input) => typia.notations.validateKebab<TypeTagNaN>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagNaN>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagObjectUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagObjectUnion.ts
new file mode 100644
index 0000000000..c373b69651
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagObjectUnion.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagObjectUnion } from "../../structures/TypeTagObjectUnion";
+
+export const test_notation_validateKebab_TypeTagObjectUnion = (): void =>
+  _test_notation_validateGeneral("TypeTagObjectUnion")<TypeTagObjectUnion>(
+    TypeTagObjectUnion,
+  )<typia.KebabCase<TypeTagObjectUnion>>({
+    convert: (input) =>
+      typia.notations.validateKebab<TypeTagObjectUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagObjectUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagPattern.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagPattern.ts
new file mode 100644
index 0000000000..a0419dceb6
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagPattern.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagPattern } from "../../structures/TypeTagPattern";
+
+export const test_notation_validateKebab_TypeTagPattern = (): void =>
+  _test_notation_validateGeneral("TypeTagPattern")<TypeTagPattern>(
+    TypeTagPattern,
+  )<typia.KebabCase<TypeTagPattern>>({
+    convert: (input) => typia.notations.validateKebab<TypeTagPattern>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagPattern>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagRange.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagRange.ts
new file mode 100644
index 0000000000..ff77c0cc0a
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagRange.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagRange } from "../../structures/TypeTagRange";
+
+export const test_notation_validateKebab_TypeTagRange = (): void =>
+  _test_notation_validateGeneral("TypeTagRange")<TypeTagRange>(TypeTagRange)<
+    typia.KebabCase<TypeTagRange>
+  >({
+    convert: (input) => typia.notations.validateKebab<TypeTagRange>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagRange>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagRangeBigInt.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagRangeBigInt.ts
new file mode 100644
index 0000000000..1ffbc47e3d
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagRangeBigInt.ts
@@ -0,0 +1,13 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagRangeBigInt } from "../../structures/TypeTagRangeBigInt";
+
+export const test_notation_validateKebab_TypeTagRangeBigInt = (): void =>
+  _test_notation_validateGeneral("TypeTagRangeBigInt")<TypeTagRangeBigInt>(
+    TypeTagRangeBigInt,
+  )<typia.KebabCase<TypeTagRangeBigInt>>({
+    convert: (input) =>
+      typia.notations.validateKebab<TypeTagRangeBigInt>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagRangeBigInt>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagTuple.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagTuple.ts
new file mode 100644
index 0000000000..04d885a7f0
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagTuple.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagTuple } from "../../structures/TypeTagTuple";
+
+export const test_notation_validateKebab_TypeTagTuple = (): void =>
+  _test_notation_validateGeneral("TypeTagTuple")<TypeTagTuple>(TypeTagTuple)<
+    typia.KebabCase<TypeTagTuple>
+  >({
+    convert: (input) => typia.notations.validateKebab<TypeTagTuple>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagTuple>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagType.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagType.ts
new file mode 100644
index 0000000000..3056cb5166
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagType.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagType } from "../../structures/TypeTagType";
+
+export const test_notation_validateKebab_TypeTagType = (): void =>
+  _test_notation_validateGeneral("TypeTagType")<TypeTagType>(TypeTagType)<
+    typia.KebabCase<TypeTagType>
+  >({
+    convert: (input) => typia.notations.validateKebab<TypeTagType>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagType>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagTypeBigInt.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagTypeBigInt.ts
new file mode 100644
index 0000000000..c674963ad3
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagTypeBigInt.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagTypeBigInt } from "../../structures/TypeTagTypeBigInt";
+
+export const test_notation_validateKebab_TypeTagTypeBigInt = (): void =>
+  _test_notation_validateGeneral("TypeTagTypeBigInt")<TypeTagTypeBigInt>(
+    TypeTagTypeBigInt,
+  )<typia.KebabCase<TypeTagTypeBigInt>>({
+    convert: (input) => typia.notations.validateKebab<TypeTagTypeBigInt>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagTypeBigInt>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_TypeTagTypeUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_TypeTagTypeUnion.ts
new file mode 100644
index 0000000000..f0370a68c2
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_TypeTagTypeUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { TypeTagTypeUnion } from "../../structures/TypeTagTypeUnion";
+
+export const test_notation_validateKebab_TypeTagTypeUnion = (): void =>
+  _test_notation_validateGeneral("TypeTagTypeUnion")<TypeTagTypeUnion>(
+    TypeTagTypeUnion,
+  )<typia.KebabCase<TypeTagTypeUnion>>({
+    convert: (input) => typia.notations.validateKebab<TypeTagTypeUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<TypeTagTypeUnion>>(),
+  });
diff --git a/test/src/features/notation.kebab/test_notation_kebab_UltimateUnion.ts b/test/src/features/notation.kebab/test_notation_kebab_UltimateUnion.ts
new file mode 100644
index 0000000000..bdd6e8dc7d
--- /dev/null
+++ b/test/src/features/notation.kebab/test_notation_kebab_UltimateUnion.ts
@@ -0,0 +1,12 @@
+import typia from "typia";
+
+import { _test_notation_validateGeneral } from "../../internal/_test_notation_validateGeneral";
+import { UltimateUnion } from "../../structures/UltimateUnion";
+
+export const test_notation_validateKebab_UltimateUnion = (): void =>
+  _test_notation_validateGeneral("UltimateUnion")<UltimateUnion>(UltimateUnion)<
+    typia.KebabCase<UltimateUnion>
+  >({
+    convert: (input) => typia.notations.validateKebab<UltimateUnion>(input),
+    assert: typia.createAssert<typia.KebabCase<UltimateUnion>>(),
+  });