@typia/interface 12.0.0-dev.20260311 → 12.0.0-dev.20260312

package/lib/openapi/OpenApiV3_2.d.ts

@@ -0,0 +1,489 @@
+import { IJsonSchemaAttribute } from "../schema/IJsonSchemaAttribute";
+import * as tags from "../tags";
+/**
+ * OpenAPI v3.2 specification types (raw, unemended).
+ *
+ * `OpenApiV3_2` contains TypeScript type definitions for raw OpenAPI v3.2
+ * documents as-is from the specification. Unlike {@link OpenApi}, this preserves
+ * the original structure including `$ref` references and `allOf` compositions
+ * without normalization.
+ *
+ * Key features in v3.2:
+ *
+ * - `query` HTTP method for safe read operations with request body
+ * - `additionalOperations` for non-standard HTTP methods (LINK, UNLINK, etc.)
+ * - `in: "querystring"` parameter location for full query schema
+ * - Enhanced Tag structure with `summary`, `parent`, `kind`
+ * - `itemSchema` for streaming (SSE, JSON Lines, etc.)
+ * - OAuth2 Device Authorization Flow
+ *
+ * For a normalized format that simplifies schema processing, use
+ * {@link OpenApi}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare namespace OpenApiV3_2 {
+    /** HTTP method of the operation. */
+    type Method = "get" | "post" | "put" | "delete" | "options" | "head" | "patch" | "trace" | "query";
+    /** OpenAPI document structure. */
+    interface IDocument {
+        /** OpenAPI version. */
+        openapi: `3.2.${number}`;
+        /** List of servers. */
+        servers?: IServer[];
+        /** API metadata. */
+        info?: IDocument.IInfo;
+        /** Reusable components. */
+        components?: IComponents;
+        /** API paths and operations. */
+        paths?: Record<string, IPath>;
+        /** Webhook definitions. */
+        webhooks?: Record<string, IJsonSchema.IReference<`#/components/pathItems/${string}`> | IPath>;
+        /** Global security requirements. */
+        security?: Record<string, string[]>[];
+        /** Tag definitions. */
+        tags?: IDocument.ITag[];
+    }
+    namespace IDocument {
+        /** API metadata. */
+        interface IInfo {
+            /** API title. */
+            title: string;
+            /** Short summary. */
+            summary?: string;
+            /** Full description. */
+            description?: string;
+            /** Terms of service URL. */
+            termsOfService?: string;
+            /** Contact information. */
+            contact?: IContact;
+            /** License information. */
+            license?: ILicense;
+            /** API version. */
+            version: string;
+        }
+        /** Tag for grouping operations. */
+        interface ITag {
+            /** Tag name. */
+            name: string;
+            /** Short summary for display in tag lists. */
+            summary?: string;
+            /** Tag description. */
+            description?: string;
+            /** Parent tag name for hierarchical organization. */
+            parent?: string;
+            /** Tag classification (e.g., "nav", "badge"). */
+            kind?: string;
+        }
+        /** Contact information. */
+        interface IContact {
+            /** Contact name. */
+            name?: string;
+            /** Contact URL. */
+            url?: string;
+            /** Contact email. */
+            email?: string & tags.Format<"email">;
+        }
+        /** License information. */
+        interface ILicense {
+            /** License name. */
+            name: string;
+            /** SPDX license identifier. */
+            identifier?: string;
+            /** License URL. */
+            url?: string;
+        }
+    }
+    /** Server providing the API. */
+    interface IServer {
+        /** Server URL. */
+        url: string;
+        /** Server description. */
+        description?: string;
+        /** URL template variables. */
+        variables?: Record<string, IServer.IVariable>;
+    }
+    namespace IServer {
+        /** URL template variable. */
+        interface IVariable {
+            /** Default value. */
+            default: string;
+            /** Allowed values. @minItems 1 */
+            enum?: string[];
+            /** Variable description. */
+            description?: string;
+        }
+    }
+    /** Path item containing operations by HTTP method. */
+    interface IPath extends Partial<Record<Method, IOperation>> {
+        /** Path-level parameters. */
+        parameters?: Array<IOperation.IParameter | IJsonSchema.IReference<`#/components/headers/${string}`> | IJsonSchema.IReference<`#/components/parameters/${string}`>>;
+        /** Path-level servers. */
+        servers?: IServer[];
+        /** Path summary. */
+        summary?: string;
+        /** Path description. */
+        description?: string;
+        /** Additional non-standard HTTP method operations (e.g., LINK, UNLINK, PURGE). */
+        additionalOperations?: Record<string, IOperation>;
+    }
+    /** API operation metadata. */
+    interface IOperation {
+        /** Unique operation identifier. */
+        operationId?: string;
+        /** Operation parameters. */
+        parameters?: Array<IOperation.IParameter | IJsonSchema.IReference<`#/components/headers/${string}`> | IJsonSchema.IReference<`#/components/parameters/${string}`>>;
+        /** Request body. */
+        requestBody?: IOperation.IRequestBody | IJsonSchema.IReference<`#/components/requestBodies/${string}`>;
+        /** Response definitions by status code. */
+        responses?: Record<string, IOperation.IResponse | IJsonSchema.IReference<`#/components/responses/${string}`>>;
+        /** Operation-level servers. */
+        servers?: IServer[];
+        /** Short summary. */
+        summary?: string;
+        /** Full description. */
+        description?: string;
+        /** Security requirements. */
+        security?: Record<string, string[]>[];
+        /** Operation tags. */
+        tags?: string[];
+        /** Whether deprecated. */
+        deprecated?: boolean;
+    }
+    namespace IOperation {
+        /** Operation parameter. */
+        interface IParameter {
+            /** Parameter name. */
+            name?: string;
+            /** Parameter location. */
+            in: "path" | "query" | "querystring" | "header" | "cookie";
+            /** Parameter schema. */
+            schema: IJsonSchema;
+            /** Whether required. */
+            required?: boolean;
+            /** Parameter description. */
+            description?: string;
+            /** Example value. */
+            example?: any;
+            /** Named examples. */
+            examples?: Record<string, IExample | IJsonSchema.IReference<`#/components/examples/${string}`>>;
+        }
+        /** Request body. */
+        interface IRequestBody {
+            /** Body description. */
+            description?: string;
+            /** Whether required. */
+            required?: boolean;
+            /** Body content by media type. */
+            content?: Record<string, IMediaType>;
+        }
+        /** Response definition. */
+        interface IResponse {
+            /** Response content by media type. */
+            content?: Record<string, IMediaType>;
+            /** Response headers. */
+            headers?: Record<string, Omit<IOperation.IParameter, "in"> | IJsonSchema.IReference<`#/components/headers/${string}`>>;
+            /** Response description. */
+            description?: string;
+        }
+        /** Media type definition. */
+        interface IMediaType {
+            /** Content schema. */
+            schema?: IJsonSchema;
+            /** Schema for streaming items (SSE, JSON Lines, etc.). */
+            itemSchema?: IJsonSchema;
+            /** Example value. */
+            example?: any;
+            /** Named examples. */
+            examples?: Record<string, IExample | IJsonSchema.IReference<`#/components/examples/${string}`>>;
+        }
+    }
+    /** Example value definition. */
+    interface IExample {
+        /** Example summary. */
+        summary?: string;
+        /** Example description. */
+        description?: string;
+        /** Example value. */
+        value?: any;
+        /** External value URL. */
+        externalValue?: string;
+    }
+    /** Reusable components storage. */
+    interface IComponents {
+        /** Named schemas. */
+        schemas?: Record<string, IJsonSchema>;
+        /** Named path items. */
+        pathItems?: Record<string, IPath>;
+        /** Named responses. */
+        responses?: Record<string, IOperation.IResponse>;
+        /** Named parameters. */
+        parameters?: Record<string, IOperation.IParameter>;
+        /** Named request bodies. */
+        requestBodies?: Record<string, IOperation.IRequestBody>;
+        /** Named security schemes. */
+        securitySchemes?: Record<string, ISecurityScheme>;
+        /** Named headers. */
+        headers?: Record<string, Omit<IOperation.IParameter, "in">>;
+        /** Named examples. */
+        examples?: Record<string, IExample>;
+    }
+    /** JSON Schema type for OpenAPI v3.1. */
+    type IJsonSchema = IJsonSchema.IMixed | IJsonSchema.IConstant | IJsonSchema.IBoolean | IJsonSchema.IInteger | IJsonSchema.INumber | IJsonSchema.IString | IJsonSchema.IArray | IJsonSchema.IObject | IJsonSchema.IReference | IJsonSchema.IRecursiveReference | IJsonSchema.IAllOf | IJsonSchema.IAnyOf | IJsonSchema.IOneOf | IJsonSchema.INull | IJsonSchema.IUnknown;
+    namespace IJsonSchema {
+        /** Mixed type (multiple types in array). */
+        interface IMixed extends IConstant, Omit<IBoolean, "type" | "default" | "enum">, Omit<INumber, "type" | "default" | "enum">, Omit<IString, "type" | "default" | "enum">, Omit<IArray, "type">, Omit<IObject, "type">, IOneOf, IAnyOf, IAllOf, IReference {
+            /** Array of type discriminators. */
+            type: Array<"boolean" | "integer" | "number" | "string" | "array" | "object" | "null">;
+            /** Default value. */
+            default?: any[] | null;
+            /** Allowed values. */
+            enum?: any[];
+        }
+        /** Constant value type. */
+        interface IConstant extends __IAttribute {
+            /** Constant value. */
+            const: boolean | number | string;
+            /** Whether nullable. */
+            nullable?: boolean;
+        }
+        /** Boolean type. */
+        interface IBoolean extends Omit<IJsonSchemaAttribute.IBoolean, "examples">, __IAttribute {
+            /** Whether nullable. */
+            nullable?: boolean;
+            /** Default value. */
+            default?: boolean | null;
+            /** Allowed values. */
+            enum?: Array<boolean | null>;
+        }
+        /** Integer type. */
+        interface IInteger extends Omit<IJsonSchemaAttribute.IInteger, "examples">, __IAttribute {
+            /** Whether nullable. */
+            nullable?: boolean;
+            /** Default value. */
+            default?: (number & tags.Type<"int64">) | null;
+            /** Allowed values. */
+            enum?: Array<(number & tags.Type<"int64">) | null>;
+            /** Minimum value. */
+            minimum?: number & tags.Type<"int64">;
+            /** Maximum value. */
+            maximum?: number & tags.Type<"int64">;
+            /** Exclusive minimum. */
+            exclusiveMinimum?: (number & tags.Type<"int64">) | boolean;
+            /** Exclusive maximum. */
+            exclusiveMaximum?: (number & tags.Type<"int64">) | boolean;
+            /** Multiple of constraint. */
+            multipleOf?: number & tags.ExclusiveMinimum<0>;
+        }
+        /** Number (double) type. */
+        interface INumber extends Omit<IJsonSchemaAttribute.INumber, "examples">, __IAttribute {
+            /** Whether nullable. */
+            nullable?: boolean;
+            /** Default value. */
+            default?: number | null;
+            /** Allowed values. */
+            enum?: Array<number | null>;
+            /** Minimum value. */
+            minimum?: number;
+            /** Maximum value. */
+            maximum?: number;
+            /** Exclusive minimum. */
+            exclusiveMinimum?: number | boolean;
+            /** Exclusive maximum. */
+            exclusiveMaximum?: number | boolean;
+            /** Multiple of constraint. */
+            multipleOf?: number & tags.ExclusiveMinimum<0>;
+        }
+        /** String type. */
+        interface IString extends Omit<IJsonSchemaAttribute.IString, "examples">, __IAttribute {
+            /** Whether nullable. */
+            nullable?: boolean;
+            /** Default value. */
+            default?: string | null;
+            /** Allowed values. */
+            enum?: Array<string | null>;
+            /** String format. */
+            format?: "binary" | "byte" | "password" | "regex" | "uuid" | "email" | "hostname" | "idn-email" | "idn-hostname" | "iri" | "iri-reference" | "ipv4" | "ipv6" | "uri" | "uri-reference" | "uri-template" | "url" | "date-time" | "date" | "time" | "duration" | "json-pointer" | "relative-json-pointer" | (string & {});
+            /** Regex pattern. */
+            pattern?: string;
+            /** Content media type. */
+            contentMediaType?: string;
+            /** Minimum length. */
+            minLength?: number & tags.Type<"uint64">;
+            /** Maximum length. */
+            maxLength?: number & tags.Type<"uint64">;
+        }
+        /** Object type. */
+        interface IObject extends Omit<IJsonSchemaAttribute.IObject, "examples">, __IAttribute {
+            /** Whether nullable. */
+            nullable?: boolean;
+            /** Property schemas. */
+            properties?: Record<string, IJsonSchema>;
+            /** Required property names. */
+            required?: string[];
+            /** Additional properties schema. */
+            additionalProperties?: boolean | IJsonSchema;
+            /** Maximum properties. */
+            maxProperties?: number;
+            /** Minimum properties. */
+            minProperties?: number;
+        }
+        /** Array type. */
+        interface IArray extends Omit<IJsonSchemaAttribute.IArray, "examples">, __IAttribute {
+            /** Whether nullable. */
+            nullable?: boolean;
+            /** Element type (or tuple types). */
+            items?: IJsonSchema | IJsonSchema[];
+            /** Tuple prefix items. */
+            prefixItems?: IJsonSchema[];
+            /** Whether elements must be unique. */
+            uniqueItems?: boolean;
+            /** Additional items schema. */
+            additionalItems?: boolean | IJsonSchema;
+            /** Minimum items. */
+            minItems?: number & tags.Type<"uint64">;
+            /** Maximum items. */
+            maxItems?: number & tags.Type<"uint64">;
+        }
+        /** Reference to a named schema. */
+        interface IReference<Key = string> extends __IAttribute {
+            /** Reference path. */
+            $ref: Key;
+        }
+        /** Recursive reference. */
+        interface IRecursiveReference extends __IAttribute {
+            /** Recursive reference path. */
+            $recursiveRef: string;
+        }
+        /** All-of combination. */
+        interface IAllOf extends __IAttribute {
+            /** Schemas to combine. */
+            allOf: IJsonSchema[];
+        }
+        /** Any-of union. */
+        interface IAnyOf extends __IAttribute {
+            /** Union member schemas. */
+            anyOf: IJsonSchema[];
+        }
+        /** One-of union. */
+        interface IOneOf extends __IAttribute {
+            /** Union member schemas. */
+            oneOf: IJsonSchema[];
+            /** Discriminator for tagged unions. */
+            discriminator?: IOneOf.IDiscriminator;
+        }
+        namespace IOneOf {
+            /** Discriminator for tagged unions. */
+            interface IDiscriminator {
+                /** Discriminator property name. */
+                propertyName: string;
+                /** Value to schema mapping. */
+                mapping?: Record<string, string>;
+            }
+        }
+        /** Null type. */
+        interface INull extends Omit<IJsonSchemaAttribute.INull, "examples">, __IAttribute {
+            /** Default value. */
+            default?: null;
+        }
+        /** Unknown type. */
+        interface IUnknown extends Omit<IJsonSchemaAttribute.IUnknown, "examples">, __IAttribute {
+            /** Type discriminator (undefined for unknown). */
+            type?: undefined;
+            /** Default value. */
+            default?: any;
+        }
+    }
+    /** Security scheme types. */
+    type ISecurityScheme = ISecurityScheme.IApiKey | ISecurityScheme.IHttpBasic | ISecurityScheme.IHttpBearer | ISecurityScheme.IOAuth2 | ISecurityScheme.IOpenId;
+    namespace ISecurityScheme {
+        /** API key authentication. */
+        interface IApiKey {
+            /** Scheme type. */
+            type: "apiKey";
+            /** Key location. */
+            in?: "header" | "query" | "cookie";
+            /** Key name. */
+            name?: string;
+            /** Scheme description. */
+            description?: string;
+        }
+        /** HTTP basic authentication. */
+        interface IHttpBasic {
+            /** Scheme type. */
+            type: "http";
+            /** Authentication scheme. */
+            scheme: "basic";
+            /** Scheme description. */
+            description?: string;
+        }
+        /** HTTP bearer authentication. */
+        interface IHttpBearer {
+            /** Scheme type. */
+            type: "http";
+            /** Authentication scheme. */
+            scheme: "bearer";
+            /** Bearer token format hint. */
+            bearerFormat?: string;
+            /** Scheme description. */
+            description?: string;
+        }
+        /** OAuth2 authentication. */
+        interface IOAuth2 {
+            /** Scheme type. */
+            type: "oauth2";
+            /** OAuth2 flows. */
+            flows: IOAuth2.IFlowSet;
+            /** OAuth2 metadata discovery URL. */
+            oauth2MetadataUrl?: string;
+            /** Scheme description. */
+            description?: string;
+        }
+        /** OpenID Connect authentication. */
+        interface IOpenId {
+            /** Scheme type. */
+            type: "openIdConnect";
+            /** OpenID Connect discovery URL. */
+            openIdConnectUrl: string;
+            /** Scheme description. */
+            description?: string;
+        }
+        namespace IOAuth2 {
+            /** OAuth2 flow configurations. */
+            interface IFlowSet {
+                /** Authorization code flow. */
+                authorizationCode?: IFlow;
+                /** Implicit flow. */
+                implicit?: Omit<IFlow, "tokenUrl">;
+                /** Password flow. */
+                password?: Omit<IFlow, "authorizationUrl">;
+                /** Client credentials flow. */
+                clientCredentials?: Omit<IFlow, "authorizationUrl">;
+                /** Device authorization flow. */
+                deviceAuthorization?: IDeviceFlow;
+            }
+            /** OAuth2 flow configuration. */
+            interface IFlow {
+                /** Authorization URL. */
+                authorizationUrl?: string;
+                /** Token URL. */
+                tokenUrl?: string;
+                /** Refresh URL. */
+                refreshUrl?: string;
+                /** Available scopes. */
+                scopes?: Record<string, string>;
+            }
+            /** OAuth2 device authorization flow. */
+            interface IDeviceFlow {
+                /** Device authorization URL. */
+                deviceAuthorizationUrl: string;
+                /** Token URL. */
+                tokenUrl: string;
+                /** Refresh URL. */
+                refreshUrl?: string;
+                /** Available scopes. */
+                scopes?: Record<string, string>;
+            }
+        }
+    }
+}

package/lib/openapi/OpenApiV3_2.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=OpenApiV3_2.js.map

package/lib/openapi/OpenApiV3_2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenApiV3_2.js","sourceRoot":"","sources":["../../src/openapi/OpenApiV3_2.ts"],"names":[],"mappings":""}

package/lib/openapi/SwaggerV2.d.ts

@@ -92,6 +92,13 @@ export declare namespace SwaggerV2 {
     interface IPath extends Partial<Record<Method, IOperation | undefined>> {
         /** Path-level parameters. */
         parameters?: Array<IOperation.IParameter | IJsonSchema.IReference<`#/parameters/${string}`>>;
+        /**
+         * Non-standard HTTP method operations (extension).
+         *
+         * Used when downgrading from OpenAPI v3.2 to preserve
+         * non-standard methods like `query` or custom methods.
+         */
+        "x-additionalOperations"?: Record<string, IOperation>;
     }
     /** API operation metadata. */
     interface IOperation {

package/lib/openapi/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./OpenApi";
 export * from "./OpenApiV3";
 export * from "./OpenApiV3_1";
+export * from "./OpenApiV3_2";
 export * from "./SwaggerV2";

package/lib/openapi/index.js

@@ -17,5 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./OpenApi"), exports);
 __exportStar(require("./OpenApiV3"), exports);
 __exportStar(require("./OpenApiV3_1"), exports);
+__exportStar(require("./OpenApiV3_2"), exports);
 __exportStar(require("./SwaggerV2"), exports);
 //# sourceMappingURL=index.js.map

package/lib/openapi/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/openapi/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4CAA0B;AAC1B,8CAA4B;AAC5B,gDAA8B;AAC9B,8CAA4B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/openapi/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4CAA0B;AAC1B,8CAA4B;AAC5B,gDAA8B;AAC9B,gDAA8B;AAC9B,8CAA4B"}

package/lib/schema/ILlmStructuredOutput.d.ts

@@ -0,0 +1,108 @@
+import { IJsonParseResult } from "./IJsonParseResult";
+import { ILlmSchema } from "./ILlmSchema";
+import { IValidation } from "./IValidation";
+/**
+ * LLM structured output schema with parsing and validation utilities.
+ *
+ * `ILlmStructuredOutput<T>` is generated by `typia.llm.structuredOutput<T>()`
+ * to provide everything needed for handling LLM structured outputs: the JSON
+ * schema for prompting, and functions for parsing, coercing, and validating
+ * responses.
+ *
+ * Structured outputs allow LLMs to generate data conforming to a predefined
+ * schema instead of free-form text. This is useful for:
+ *
+ * - Extracting structured data from conversations
+ * - Generating typed responses for downstream processing
+ * - Ensuring consistent output formats across LLM calls
+ *
+ * Workflow:
+ *
+ * 1. Pass {@link parameters} schema to LLM provider
+ * 2. Receive LLM response (JSON string or pre-parsed object)
+ * 3. Use {@link parse} for raw strings or {@link coerce} for pre-parsed objects
+ * 4. Use {@link validate} to check the result and get detailed errors
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T The expected output type
+ */
+export interface ILlmStructuredOutput<T = unknown> {
+    /**
+     * JSON schema for the structured output.
+     *
+     * Pass this schema to LLM providers (OpenAI, Anthropic, Google, etc.) to
+     * constrain the output format. The schema includes `$defs` for shared type
+     * definitions and `properties` for the output structure.
+     *
+     * Most LLM providers accept this directly in their structured output or
+     * response format configuration.
+     */
+    parameters: ILlmSchema.IParameters;
+    /**
+     * Lenient JSON parser with schema-based type coercion.
+     *
+     * Handles incomplete or malformed JSON commonly produced by LLMs:
+     *
+     * - Unclosed brackets, strings, trailing commas
+     * - JavaScript-style comments (`//` and multi-line)
+     * - Unquoted object keys, incomplete keywords (`tru`, `fal`, `nul`)
+     * - Markdown code block extraction, junk prefix skipping
+     *
+     * Also coerces double-stringified values based on the schema:
+     *
+     * - `"42"` → `42` (when schema expects number)
+     * - `"true"` → `true` (when schema expects boolean)
+     * - `"null"` → `null` (when schema expects null)
+     * - `"{...}"` → `{...}` (when schema expects object)
+     * - `"[...]"` → `[...]` (when schema expects array)
+     *
+     * Type validation is NOT performed — use {@link validate} after parsing.
+     *
+     * If the SDK (e.g., LangChain, Vercel AI, MCP) already parses JSON internally
+     * and provides a pre-parsed object, use {@link coerce} instead.
+     *
+     * @param input Raw JSON string from LLM output
+     * @returns Parse result with data on success, or partial data with errors
+     */
+    parse: (input: string) => IJsonParseResult<T>;
+    /**
+     * Coerce pre-parsed output to match expected schema types.
+     *
+     * **Use this only when the SDK already parses JSON internally.** For raw JSON
+     * strings from LLM output, use {@link parse} instead — it handles both lenient
+     * parsing and type coercion in one step.
+     *
+     * LLMs often return values with incorrect types even after parsing:
+     *
+     * - `"42"` → `42` (when schema expects number)
+     * - `"true"` → `true` (when schema expects boolean)
+     * - `"null"` → `null` (when schema expects null)
+     * - `"{...}"` → `{...}` (when schema expects object)
+     * - `"[...]"` → `[...]` (when schema expects array)
+     *
+     * This function recursively coerces these double-stringified values based on
+     * the {@link parameters} schema.
+     *
+     * Type validation is NOT performed — use {@link validate} after coercion.
+     *
+     * @param input Pre-parsed output object from SDK
+     * @returns Coerced output with corrected types
+     */
+    coerce: (input: unknown) => T;
+    /**
+     * Validates LLM-generated output against the schema.
+     *
+     * LLMs frequently make type errors such as returning strings instead of
+     * numbers or missing required properties. Use this validator to check output
+     * before further processing.
+     *
+     * When validation fails, use {@link LlmJson.stringify} from `@typia/utils` to
+     * format the error for LLM feedback. The formatted output shows the invalid
+     * JSON with inline error comments, helping the LLM understand and correct its
+     * mistakes in the next turn.
+     *
+     * @param input The output generated by the LLM
+     * @returns Validation result with success status and any errors
+     */
+    validate: (input: unknown) => IValidation<T>;
+}

package/lib/schema/ILlmStructuredOutput.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ILlmStructuredOutput.js.map

package/lib/schema/ILlmStructuredOutput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ILlmStructuredOutput.js","sourceRoot":"","sources":["../../src/schema/ILlmStructuredOutput.ts"],"names":[],"mappings":""}

package/lib/schema/index.d.ts

@@ -9,4 +9,5 @@ export * from "./ILlmController";
 export * from "./ILlmApplication";
 export * from "./ILlmFunction";
 export * from "./ILlmSchema";
+export * from "./ILlmStructuredOutput";
 export * from "./IJsonParseResult";

package/lib/schema/index.js

@@ -25,5 +25,6 @@ __exportStar(require("./ILlmController"), exports);
 __exportStar(require("./ILlmApplication"), exports);
 __exportStar(require("./ILlmFunction"), exports);
 __exportStar(require("./ILlmSchema"), exports);
+__exportStar(require("./ILlmStructuredOutput"), exports);
 __exportStar(require("./IJsonParseResult"), exports);
 //# sourceMappingURL=index.js.map

package/lib/schema/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4CAA0B;AAC1B,gDAA8B;AAE9B,8DAA4C;AAC5C,2DAAyC;AACzC,0DAAwC;AACxC,oDAAkC;AAClC,yDAAuC;AAEvC,mDAAiC;AACjC,oDAAkC;AAClC,iDAA+B;AAC/B,+CAA6B;AAC7B,qDAAmC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4CAA0B;AAC1B,gDAA8B;AAE9B,8DAA4C;AAC5C,2DAAyC;AACzC,0DAAwC;AACxC,oDAAkC;AAClC,yDAAuC;AAEvC,mDAAiC;AACjC,oDAAkC;AAClC,iDAA+B;AAC/B,+CAA6B;AAC7B,yDAAuC;AACvC,qDAAmC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typia/interface",
-  "version": "12.0.0-dev.20260311",
+  "version": "12.0.0-dev.20260312",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {