interface User {
  string: string;                             // String
  lowCardinality: string & LowCardinality;    // LowCardinality(String)
  uuid: string & tags.Format<"uuid">;         // UUID (with typia tags)
}

import { Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64 } from "@514labs/moose-lib";
 
interface Metrics {
  user_id: Int32;           // Int32
  count: UInt64;            // UInt64
  small_value: Int8;        // Int8
}
 
// Alternative: You can still use the verbose syntax if preferred
interface MetricsVerbose {
  user_id: number & ClickHouseInt<"int32">;
  count: number & ClickHouseInt<"uint64">;
  small_value: number & ClickHouseInt<"int8">;
}

import { Float32, Float64 } from "@514labs/moose-lib";
import { tags } from "typia";
 
interface SensorData {
  temperature: Float32;                     // Float32
  humidity: Float64;                        // Float64
  pressure: number;                         // Default Float64
}
 
// Alternative: You can still use the verbose syntax if preferred
interface SensorDataVerbose {
  temperature: number & tags.Type<"float">; // Float32
  humidity: number;                         // Float64
}

import { Decimal, ClickHouseDecimal } from "@514labs/moose-lib";
 
interface FinancialData {
  amount: Decimal<10, 2>;                     // Decimal(10,2)
  rate: Decimal<5, 4>;                        // Decimal(5,4)
  fee: Decimal<8, 3>;                         // Decimal(8,3)
}
 
// Alternative: You can still use the verbose syntax if preferred
interface FinancialDataVerbose {
  amount: string & ClickHouseDecimal<10, 2>;  // Decimal(10,2)
  rate: string & ClickHouseDecimal<5, 4>;     // Decimal(5,4)
}

interface User {
  is_active: boolean;
  verified: boolean;
}

import { DateTime, DateTime64, ClickHousePrecision } from "@514labs/moose-lib";
 
interface Event {
  created_at: DateTime;                               // DateTime
  updated_at: DateTime64<3>;                         // DateTime(3)
  logged_at: DateTime64<6>;                          // DateTime(6) - microsecond precision
  birth_date: Date;                                   // Date
}
 
// Alternative: You can still use the verbose syntax if preferred
interface EventVerbose {
  created_at: Date;                                   // DateTime
  updated_at: Date & ClickHousePrecision<3>;         // DateTime(3)
  birth_date: Date;                                   // Date
}

import { tags } from "typia";
 
interface NetworkEvent {
  source_ip: string & tags.Format<"ipv4">;
  dest_ip: string & tags.Format<"ipv6">;
}

import {
  ClickHousePoint,
  ClickHouseRing,
  ClickHouseLineString,
  ClickHouseMultiLineString,
  ClickHousePolygon,
  ClickHouseMultiPolygon,
} from "@514labs/moose-lib";
 
interface GeoTypes {
  point: ClickHousePoint;                 // Point → [number, number]
  ring: ClickHouseRing;                   // Ring → Array<[number, number]>
  lineString: ClickHouseLineString;       // LineString → Array<[number, number]>
  multiLineString: ClickHouseMultiLineString; // MultiLineString → Array<Array<[number, number]>>
  polygon: ClickHousePolygon;             // Polygon → Array<Array<[number, number]>>
  multiPolygon: ClickHouseMultiPolygon;   // MultiPolygon → Array<Array<Array<[number, number]>>>
}

interface User {
  tags: string[];           // Array(String)
  scores: number[];         // Array(Float64)
  metadata: Record<string, any>[];  // Array(Json)
  tuple: {
    name: string;
    age: number;
  } & ClickHouseNamedTuple[]; // Array(Tuple(String, Int32))
}

interface User {
  preferences: Record<string, string>;     // Map(String, String)
  metrics: Record<string, number>;         // Map(String, Float64)
}

interface Address {
  street: string;
  city: string;
  zip: string;
}
 
interface User {
  name: string;
  address: Address;  // Nested type
}

import { ClickHouseNamedTuple } from "@514labs/moose-lib";
 
interface Point {
  x: number;
  y: number;
}
 
interface Shape {
  center: Point & ClickHouseNamedTuple;  // Named tuple
  radius: number;
}

enum UserRole {
  ADMIN = "admin",
  USER = "user",
  GUEST = "guest"
}
 
interface User {
  role: UserRole;  // Enum with string values
}

interface Event {
  metadata: Record<string, any>;  // Basic JSON - accepts any structure
  config: any;                    // Basic JSON - fully dynamic
}

import { ClickHouseJson } from "@514labs/moose-lib";
 
// Define the structure for your JSON payload
interface PayloadStructure {
  name: string;
  count: number;
  timestamp?: Date;
}
 
interface Event {
  id: string;
  // JSON with typed paths - better performance, allows extra fields
  payload: PayloadStructure & ClickHouseJson;
  
  // JSON with performance tuning options
  metadata: PayloadStructure & ClickHouseJson<
    256,      // max_dynamic_paths: limit tracked paths (default: no limit)
    16,       // max_dynamic_types: limit type variations (default: no limit)
    ["skip.me"],           // skip_paths: exclude specific paths
    ["^tmp\\."]            // skip_regexps: exclude paths matching regex
  >;
}

import { ClickHouseJson, Key } from "@514labs/moose-lib";
 
interface ProductProperties {
  category: string;
  price: number;
  inStock: boolean;
}
 
interface ProductEvent {
  eventId: Key<string>;
  timestamp: DateTime;
  // Typed paths for common fields, but allows custom properties
  properties: ProductProperties & ClickHouseJson<
    128,                    // Track up to 128 unique paths
    8,                      // Allow up to 8 type variations per path
    ["_internal"],          // Ignore internal fields
    ["^debug_"]             // Ignore debug fields
  >;
}

{
  "eventId": "evt_123",
  "timestamp": "2025-10-22T12:00:00Z",
  "properties": {
    "category": "electronics",     // Typed field ✓
    "price": 99.99,                // Typed field ✓
    "inStock": true,               // Typed field ✓
    "customTag": "holiday-sale",   // Extra field - accepted ✓
    "brandId": 42,                 // Extra field - accepted ✓
    "_internal": "ignored"         // Skipped by skip_paths ✓
  }
}

interface User {
  name: string;           // Required
  email?: string;         // Nullable
  age?: number;           // Nullable
}

import { SimpleAggregated, OlapTable, ClickHouseEngines, Key, DateTime } from "@514labs/moose-lib";
 
interface DailyStats {
  date: DateTime;
  userId: string;
  totalViews: number & SimpleAggregated<"sum", number>;
  maxScore: number & SimpleAggregated<"max", number>;
  lastSeen: DateTime & SimpleAggregated<"anyLast", DateTime>;
}
 
const statsTable = new OlapTable<DailyStats>("daily_stats", {
  engine: ClickHouseEngines.AggregatingMergeTree,
  orderByFields: ["date", "userId"],
});

import { ClickHouseEngines } from "@514labs/moose-lib";
 
const userTable = new OlapTable<User>("users", {
  engine: ClickHouseEngines.ReplacingMergeTree,
  orderByFields: ["id", "updated_at"]
});