{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"npm-openai-guardrails","slug":"openai-guardrails","name":"@openai/guardrails","type":"framework","url":"https://openai.github.io/openai-guardrails-js/","page_url":"https://unfragile.ai/openai-guardrails","categories":["automation"],"tags":["guardrails","ai","safety","validation","typescript","openai"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"npm-openai-guardrails__cap_0","uri":"capability://safety.moderation.declarative.guardrail.policy.definition.with.yaml.json.schemas","name":"declarative guardrail policy definition with yaml/json schemas","description":"Enables developers to define safety policies, content filters, and validation rules using declarative YAML or JSON configuration files rather than imperative code. The framework parses these schemas at runtime and compiles them into executable guardrail chains that intercept and validate LLM inputs/outputs before they reach users or downstream systems. Supports conditional logic, regex patterns, semantic matching, and custom validator functions within a unified policy language.","intents":["Define content moderation rules without writing custom validation code","Version control safety policies alongside application code","Enable non-technical stakeholders to adjust guardrails without code changes","Reuse guardrail policies across multiple AI applications"],"best_for":["teams building production LLM applications requiring compliance auditing","organizations needing policy-as-code for AI safety","developers wanting separation of safety logic from application logic"],"limitations":["Schema validation adds ~50-150ms per request depending on rule complexity","No built-in support for dynamic policy updates without application restart","Limited to synchronous rule evaluation — async validators require custom implementation"],"requires":["TypeScript 4.5+ or Node.js 16+","YAML or JSON parser (included)","Valid guardrail schema conforming to OpenAI Guardrails specification"],"input_types":["YAML configuration files","JSON policy objects","TypeScript configuration objects"],"output_types":["compiled guardrail chain objects","validation result objects with pass/fail status"],"categories":["safety-moderation","configuration-management"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-openai-guardrails__cap_1","uri":"capability://safety.moderation.multi.stage.input.output.validation.pipeline.with.semantic.and.syntactic.checks","name":"multi-stage input/output validation pipeline with semantic and syntactic checks","description":"Implements a composable pipeline architecture that chains multiple validation stages (pre-processing, semantic analysis, syntactic checks, custom validators) to sanitize and validate both user inputs and LLM outputs. Each stage can apply different validation strategies: regex-based pattern matching, semantic similarity scoring against prohibited content vectors, PII detection, token-level analysis, and custom JavaScript functions. Stages execute sequentially with early exit on failure, and results include detailed violation metadata for logging and user feedback.","intents":["Prevent prompt injection attacks by validating input structure and content","Block harmful LLM outputs before they reach end users","Detect and redact personally identifiable information in conversations","Validate outputs conform to expected format/schema before downstream processing"],"best_for":["developers building customer-facing chatbots requiring input sanitization","teams implementing PII detection and redaction workflows","applications requiring multi-layer validation (syntax + semantic + custom logic)"],"limitations":["Semantic validation requires embedding model calls, adding 200-500ms latency per request","Custom validator functions must be synchronous — async operations require wrapper patterns","Pipeline configuration complexity grows with number of validation stages","No built-in caching of semantic validation results across similar inputs"],"requires":["TypeScript 4.5+","OpenAI API key for semantic validation stages","Embedding model access (text-embedding-3-small or equivalent)"],"input_types":["text strings (user messages)","structured objects (LLM responses with metadata)","token arrays"],"output_types":["validation result objects with pass/fail and violation details","sanitized/redacted text","structured validation reports"],"categories":["safety-moderation","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-openai-guardrails__cap_10","uri":"capability://safety.moderation.audit.logging.and.compliance.reporting.with.violation.tracking","name":"audit logging and compliance reporting with violation tracking","description":"Automatically logs all guardrail violations with detailed metadata (timestamp, user ID, violation type, severity, enforcement action, conversation context) to enable compliance auditing and threat analysis. Supports structured logging to external systems (databases, logging services) and generates compliance reports summarizing violation patterns, enforcement actions, and policy effectiveness. Includes PII-safe logging that redacts sensitive information from logs while maintaining audit trail integrity.","intents":["Maintain audit trails for compliance with regulations (GDPR, HIPAA, SOC 2)","Analyze violation patterns to identify emerging threats or policy gaps","Generate compliance reports for auditors and regulators","Debug guardrail behavior and tune policies based on real-world violations"],"best_for":["regulated industries (healthcare, finance, legal) requiring audit trails","teams needing to demonstrate compliance to auditors","applications with security monitoring and threat analysis requirements"],"limitations":["Logging adds overhead — structured logging to external systems can add 50-200ms latency","Storing full conversation context in logs creates data retention and privacy concerns","Log volume can be high in applications with strict policies — requires log aggregation/filtering","No built-in log analysis — requires external tools for pattern detection and reporting","PII redaction in logs may reduce debugging utility"],"requires":["TypeScript 4.5+","External logging system (database, logging service, or file system)","Configured logging policy and retention rules"],"input_types":["guardrail violation events with metadata"],"output_types":["structured log entries","compliance reports with violation summaries","audit trail exports"],"categories":["safety-moderation","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-openai-guardrails__cap_11","uri":"capability://code.generation.editing.typescript.first.type.safe.guardrail.configuration.and.validation","name":"typescript-first type-safe guardrail configuration and validation","description":"Provides TypeScript interfaces and type definitions for guardrail configuration, enabling compile-time validation of policy definitions and IDE autocomplete for configuration options. Supports both YAML/JSON configuration files (with TypeScript schema validation) and programmatic configuration using TypeScript objects. Type safety extends to custom validator functions, ensuring they conform to expected signatures and receive properly typed context objects.","intents":["Catch configuration errors at compile time rather than runtime","Use IDE autocomplete to discover available guardrail options","Ensure custom validators have correct function signatures","Refactor guardrail policies with confidence using TypeScript's type system"],"best_for":["TypeScript projects wanting type safety for guardrail configuration","teams using IDEs with TypeScript support (VS Code, WebStorm, etc.)","developers preferring programmatic configuration over YAML"],"limitations":["TypeScript-only — no native support for JavaScript or Python","YAML configuration files require separate schema validation — not as tight as TypeScript","Type definitions may lag behind new guardrail features","Programmatic configuration requires TypeScript knowledge — less accessible to non-developers"],"requires":["TypeScript 4.5+","TypeScript compiler and IDE with TypeScript support"],"input_types":["TypeScript configuration objects","YAML/JSON files with TypeScript schema validation"],"output_types":["compiled guardrail configuration","type-checked custom validator functions"],"categories":["code-generation-editing","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-openai-guardrails__cap_12","uri":"capability://tool.use.integration.framework.agnostic.middleware.integration.for.express.next.js.and.other.node.js.servers","name":"framework-agnostic middleware integration for express, next.js, and other node.js servers","description":"Provides middleware adapters for popular Node.js frameworks (Express, Next.js, Fastify, etc.) that integrate guardrails into request/response pipelines. Middleware intercepts requests before they reach route handlers, applies guardrails to user input, and intercepts responses to validate LLM output before sending to clients. Supports both synchronous and asynchronous middleware patterns and integrates with framework-specific error handling and logging.","intents":["Add guardrails to existing Express/Next.js applications without major refactoring","Validate user input at the HTTP middleware layer before application logic","Filter LLM responses before sending to clients","Integrate guardrails with framework-specific error handling and logging"],"best_for":["teams with existing Express/Next.js applications adding LLM features","developers wanting minimal changes to existing application architecture","applications requiring guardrails at the HTTP layer"],"limitations":["Middleware integration adds latency to every request — may impact performance on high-traffic applications","Framework-specific adapters require maintenance as frameworks evolve","Limited to Node.js frameworks — no support for Python, Go, or other runtimes","Middleware-level validation may be too late for some attacks (e.g., if application logic already processed input)"],"requires":["TypeScript 4.5+","Express 4.0+, Next.js 12+, or compatible Node.js framework","Configured guardrail policy"],"input_types":["HTTP requests with user input","HTTP responses with LLM output"],"output_types":["validated requests passed to route handlers","filtered responses sent to clients"],"categories":["tool-use-integration","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-openai-guardrails__cap_2","uri":"capability://safety.moderation.prompt.injection.attack.detection.via.structural.analysis","name":"prompt injection attack detection via structural analysis","description":"Detects prompt injection attempts by analyzing input structure, token patterns, and semantic anomalies that indicate attempts to override system instructions or manipulate model behavior. Uses techniques including delimiter detection (looking for common injection markers like 'ignore previous instructions'), instruction-like pattern recognition, and comparison against baseline input distributions. Can be configured with custom injection patterns and severity thresholds, and provides detailed reports on detected injection vectors.","intents":["Identify and block prompt injection attacks before they reach the LLM","Log injection attempts for security auditing and threat analysis","Prevent users from manipulating system prompts or jailbreaking guardrails","Detect indirect injection attempts through multi-turn conversations"],"best_for":["teams operating public-facing LLM applications vulnerable to adversarial input","security-conscious organizations requiring injection attack logging","applications with strict instruction-following requirements (e.g., financial advisors)"],"limitations":["Detection heuristics may have false positives on legitimate complex queries","Sophisticated injection attacks using paraphrasing or encoding may evade pattern-based detection","Requires tuning thresholds per application domain to balance security vs usability","No protection against indirect injections through external data sources (documents, APIs)"],"requires":["TypeScript 4.5+","Configured guardrail policy with injection detection rules","Optional: custom injection pattern definitions"],"input_types":["text strings (user messages)","multi-turn conversation histories"],"output_types":["boolean pass/fail result","injection detection report with identified patterns and severity"],"categories":["safety-moderation","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-openai-guardrails__cap_3","uri":"capability://safety.moderation.content.moderation.with.semantic.similarity.scoring.against.prohibited.topic.vectors","name":"content moderation with semantic similarity scoring against prohibited topic vectors","description":"Implements semantic content moderation by embedding user inputs and LLM outputs, then computing cosine similarity against pre-built vectors representing prohibited topics (violence, hate speech, sexual content, etc.). Uses OpenAI embeddings or custom embedding models to generate vector representations, compares against a configurable library of harmful content vectors, and returns similarity scores with configurable thresholds for blocking. Supports category-specific thresholds and allows whitelisting of legitimate uses of sensitive topics.","intents":["Block harmful content (violence, hate speech, sexual content) without manual review","Detect context-aware harmful content that regex patterns miss","Enforce category-specific content policies (e.g., stricter on violence than medical discussions)","Generate moderation confidence scores for human review workflows"],"best_for":["platforms requiring automated content moderation at scale","applications serving diverse audiences with varying content tolerance","teams wanting semantic understanding of harmful content beyond keyword matching"],"limitations":["Embedding API calls add 200-500ms latency per request","Requires pre-computed vector library for prohibited topics — no zero-shot detection","Similarity thresholds are domain-specific and require tuning per application","May miss novel harmful content not represented in training vectors","Embedding-based detection can be evaded by paraphrasing or encoding attacks"],"requires":["TypeScript 4.5+","OpenAI API key with embeddings model access","Pre-configured prohibited topic vectors or access to OpenAI's moderation vectors"],"input_types":["text strings (user messages or LLM outputs)"],"output_types":["similarity scores (0-1 range)","category-specific moderation results","pass/fail decision with confidence"],"categories":["safety-moderation","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-openai-guardrails__cap_4","uri":"capability://safety.moderation.structured.output.validation.with.schema.enforcement","name":"structured output validation with schema enforcement","description":"Validates LLM outputs against JSON schemas or TypeScript interfaces to ensure responses conform to expected structure, data types, and constraints. Parses LLM text output, attempts to extract JSON, validates against provided schema using JSON Schema validators, and returns structured validation results with detailed error messages indicating which fields failed validation. Supports nested schemas, array validation, enum constraints, and custom validation functions for business logic (e.g., 'price must be positive').","intents":["Ensure LLM outputs can be safely parsed and used by downstream code","Validate that generated JSON conforms to API contract expectations","Enforce business logic constraints on LLM-generated data (ranges, enums, required fields)","Provide detailed error messages when LLM output doesn't match expected schema"],"best_for":["developers building LLM-powered APIs that return structured data","applications requiring guaranteed output format for downstream processing","teams using LLMs to generate database records or API payloads"],"limitations":["Requires LLM to output valid JSON — malformed JSON causes validation failure","Schema validation doesn't guarantee semantic correctness (e.g., 'name' field is a string but may be nonsensical)","Complex nested schemas can be difficult for LLMs to generate correctly","No automatic schema repair — validation failures require LLM retry or fallback"],"requires":["TypeScript 4.5+","JSON Schema or TypeScript interface definitions","JSON Schema validator library (included or external)"],"input_types":["text strings containing JSON (LLM outputs)","JSON objects"],"output_types":["parsed and validated JSON objects","validation error reports with field-level details"],"categories":["safety-moderation","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-openai-guardrails__cap_5","uri":"capability://safety.moderation.personally.identifiable.information.pii.detection.and.redaction","name":"personally identifiable information (pii) detection and redaction","description":"Detects and redacts personally identifiable information (names, email addresses, phone numbers, SSNs, credit card numbers, etc.) from both user inputs and LLM outputs using pattern matching, named entity recognition, and configurable regex rules. Supports multiple redaction strategies: masking (replacing with asterisks), tokenization (replacing with placeholder tokens), removal, or encryption. Provides detailed reports on detected PII types and locations, enabling audit trails and compliance logging.","intents":["Prevent accidental exposure of user PII in LLM responses","Redact sensitive information from user inputs before sending to LLM","Maintain audit logs of PII detection for compliance (GDPR, HIPAA, etc.)","Implement data minimization by removing unnecessary PII from conversations"],"best_for":["applications handling user data subject to privacy regulations (GDPR, CCPA, HIPAA)","customer service chatbots that may receive sensitive information","teams requiring PII audit trails for compliance reporting"],"limitations":["Pattern-based detection misses context-dependent PII (e.g., 'John' as a name vs common word)","Named entity recognition requires language model inference, adding latency","Redaction may break semantic meaning (e.g., 'Call me at [REDACTED]' is awkward)","No detection of indirect PII (e.g., combination of age + location that identifies individual)","Requires tuning per domain — medical records have different PII patterns than financial data"],"requires":["TypeScript 4.5+","Configured PII detection rules (patterns and NER models)","Optional: NER model for entity recognition (adds ~100-300ms latency)"],"input_types":["text strings (user messages or LLM outputs)"],"output_types":["redacted text with PII replaced","PII detection report with types and locations","structured PII metadata for audit logging"],"categories":["safety-moderation","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-openai-guardrails__cap_6","uri":"capability://safety.moderation.custom.validator.function.registration.and.chaining","name":"custom validator function registration and chaining","description":"Allows developers to register custom JavaScript/TypeScript validation functions that execute as stages in the guardrail pipeline, enabling domain-specific validation logic beyond built-in checks. Custom validators receive input/output context (including conversation history, user metadata, LLM model info) and return validation results with pass/fail status and optional violation metadata. Validators are composable — multiple custom validators can be chained together, with early exit on failure and configurable error handling (fail-open vs fail-closed).","intents":["Implement domain-specific validation rules (e.g., 'financial advice must include risk disclaimers')","Integrate external validation services (fraud detection APIs, compliance checkers)","Add application-specific business logic to guardrails (e.g., user role-based content filtering)","Build custom detectors for emerging threat patterns"],"best_for":["teams with specialized validation requirements beyond standard guardrails","applications integrating external validation services or APIs","developers building domain-specific LLM applications (medical, legal, financial)"],"limitations":["Custom validators must be synchronous — async operations require wrapper patterns or polling","Validator performance directly impacts request latency — slow validators block the pipeline","No built-in error handling for validator exceptions — developers must implement try-catch","Validators have access to full conversation context, creating potential data leakage if not carefully designed","Testing and debugging custom validators requires integration testing with full pipeline"],"requires":["TypeScript 4.5+","Understanding of guardrail validator interface and context object","Synchronous validation logic (async requires custom wrapper implementation)"],"input_types":["validator context objects containing input/output text, conversation history, metadata"],"output_types":["validation result objects with pass/fail status and violation metadata"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-openai-guardrails__cap_7","uri":"capability://safety.moderation.conversation.aware.guardrail.enforcement.with.multi.turn.context","name":"conversation-aware guardrail enforcement with multi-turn context","description":"Applies guardrails with awareness of conversation history and context, enabling detection of policy violations that span multiple turns or depend on prior messages. Validators receive full conversation history, allowing detection of patterns like: repeated attempts to bypass guardrails, gradual escalation of harmful requests, or context-dependent violations (e.g., 'tell me a joke' is fine, but 'tell me a joke about [protected group]' is not). Supports conversation state tracking and can enforce per-user or per-session policies.","intents":["Detect multi-turn jailbreak attempts that escalate gradually across messages","Enforce conversation-level policies (e.g., 'max 3 policy violations per session before blocking')","Provide context-aware moderation that understands prior messages","Implement user-specific or session-specific guardrail rules"],"best_for":["multi-turn chatbot applications requiring sophisticated attack detection","applications with per-user or per-session policy enforcement","teams building conversational AI with adversarial robustness requirements"],"limitations":["Requires storing and analyzing full conversation history — adds memory overhead","Pattern detection across turns is heuristic-based and may have false positives","Conversation state tracking requires external persistence for multi-instance deployments","No built-in mechanism for conversation state cleanup — requires manual pruning","Analyzing long conversations adds latency — may require conversation summarization for performance"],"requires":["TypeScript 4.5+","Conversation history storage (in-memory or external database)","Configured multi-turn validation rules"],"input_types":["current user message","full conversation history (array of prior messages with metadata)"],"output_types":["validation result with conversation-level context","pattern detection reports (e.g., 'escalating jailbreak attempt detected')"],"categories":["safety-moderation","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-openai-guardrails__cap_8","uri":"capability://safety.moderation.configurable.severity.levels.and.policy.enforcement.modes","name":"configurable severity levels and policy enforcement modes","description":"Supports multiple enforcement modes (block, warn, log, custom) with configurable severity levels for different violation types, enabling graduated responses to policy violations. Violations can be categorized by severity (critical, high, medium, low) and enforcement mode (hard block, soft warning, audit logging only, custom handler). Allows different rules to have different enforcement modes — e.g., prompt injection attempts are hard-blocked while mild toxicity triggers warnings. Supports A/B testing of policy strictness through configuration without code changes.","intents":["Implement graduated enforcement (block critical violations, warn on minor ones)","Test policy strictness changes without code deployment","Provide audit logging for compliance without blocking legitimate use","Support different enforcement levels for different user segments or applications"],"best_for":["teams rolling out new safety policies gradually to minimize false positives","applications requiring different enforcement levels for different user tiers","organizations needing audit trails without blocking user interactions"],"limitations":["Soft warnings may not prevent harmful behavior — requires user cooperation","Custom enforcement handlers add complexity and potential for misconfiguration","No built-in A/B testing framework — requires external experimentation platform","Enforcement mode changes require configuration updates and potential application restart"],"requires":["TypeScript 4.5+","Configured severity levels and enforcement modes in guardrail policy"],"input_types":["guardrail policy configuration with severity and enforcement mode settings"],"output_types":["enforcement decision (block/warn/log/custom)","violation report with severity level"],"categories":["safety-moderation","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-openai-guardrails__cap_9","uri":"capability://safety.moderation.integration.with.openai.api.for.semantic.validation.and.moderation","name":"integration with openai api for semantic validation and moderation","description":"Provides native integration with OpenAI's API for semantic validation tasks including embeddings (for similarity-based content filtering), moderation endpoint (for toxicity/hate speech detection), and chat completions (for complex reasoning-based validation). Handles API authentication, rate limiting, retry logic, and error handling transparently. Supports fallback strategies when OpenAI APIs are unavailable and caching of embedding results to reduce API calls.","intents":["Use OpenAI's moderation API for toxicity and hate speech detection","Leverage embeddings for semantic similarity-based content filtering","Implement reasoning-based validation using GPT for complex policy checks","Reduce API costs through intelligent caching and batching"],"best_for":["teams already using OpenAI APIs and wanting integrated safety","applications requiring OpenAI's moderation capabilities","developers wanting to avoid managing multiple API integrations"],"limitations":["Requires valid OpenAI API key — adds dependency on OpenAI service availability","API calls add latency (200-500ms per embedding, 500-2000ms per moderation call)","Costs scale with request volume — embedding/moderation calls incur per-token charges","Caching reduces costs but adds complexity and potential staleness","No support for alternative embedding models or moderation services without custom implementation"],"requires":["TypeScript 4.5+","Valid OpenAI API key with embeddings and moderation access","Network connectivity to OpenAI API endpoints"],"input_types":["text strings for moderation or embedding"],"output_types":["moderation results (categories and scores)","embedding vectors","reasoning-based validation results"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":35,"verified":false,"data_access_risk":"high","permissions":["TypeScript 4.5+ or Node.js 16+","YAML or JSON parser (included)","Valid guardrail schema conforming to OpenAI Guardrails specification","TypeScript 4.5+","OpenAI API key for semantic validation stages","Embedding model access (text-embedding-3-small or equivalent)","External logging system (database, logging service, or file system)","Configured logging policy and retention rules","TypeScript compiler and IDE with TypeScript support","Express 4.0+, Next.js 12+, or compatible Node.js framework"],"failure_modes":["Schema validation adds ~50-150ms per request depending on rule complexity","No built-in support for dynamic policy updates without application restart","Limited to synchronous rule evaluation — async validators require custom implementation","Semantic validation requires embedding model calls, adding 200-500ms latency per request","Custom validator functions must be synchronous — async operations require wrapper patterns","Pipeline configuration complexity grows with number of validation stages","No built-in caching of semantic validation results across similar inputs","Logging adds overhead — structured logging to external systems can add 50-200ms latency","Storing full conversation context in logs creates data retention and privacy concerns","Log volume can be high in applications with strict policies — requires log aggregation/filtering","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.2263494041721882,"quality":0.35,"ecosystem":0.5800000000000001,"match_graph":0.25,"freshness":0.6,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:23.902Z","last_scraped_at":"2026-05-03T14:04:47.473Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":9172,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=openai-guardrails","compare_url":"https://unfragile.ai/compare?artifact=openai-guardrails"}},"signature":"Nlbc2RCmzuG4kJFCZFdUixV2Fp48JIVMYEz+AmbDX4qqjBtmpSQKx6DBT01phphEU/8pD/aI8UfMY/Jm9KNfDQ==","signedAt":"2026-06-21T04:06:23.144Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/openai-guardrails","artifact":"https://unfragile.ai/openai-guardrails","verify":"https://unfragile.ai/api/v1/verify?slug=openai-guardrails","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}