@synova-cloud/sdk 1.5.0 → 1.7.0

package/dist/index.d.cts

@@ -1,24 +1,82 @@
-type TSynovaMessageRole = 'system' | 'user' | 'assistant' | 'tool';
-type TSynovaResponseType = 'message' | 'tool_calls' | 'image' | 'audio' | 'error';
-type TSynovaModelType = 'text' | 'image';
-type TSynovaUsageType = 'tokens' | 'images' | 'time';
-type TSynovaJsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array';
-interface ISynovaJsonSchema {
-    /** Schema type */
-    type?: TSynovaJsonSchemaType;
-    /** Description of the field */
+/**
+ * JSON Schema primitive types
+ */
+type TJsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array';
+/**
+ * JSON Schema string formats
+ * @see https://json-schema.org/understanding-json-schema/reference/string#built-in-formats
+ */
+type TJsonSchemaFormat = 'date-time' | 'date' | 'time' | 'duration' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'iri-reference' | 'uuid' | 'json-pointer' | 'relative-json-pointer' | 'regex';
+/**
+ * JSON Schema definition
+ * @see https://json-schema.org/specification
+ */
+interface IJsonSchema {
+    type?: TJsonSchemaType | TJsonSchemaType[];
     description?: string;
-    /** Allowed values (for enum-like fields) */
+    examples?: unknown[];
+    default?: unknown;
     enum?: (string | number | boolean | null)[];
-    /** Schema for array items (when type='array') */
-    items?: ISynovaJsonSchema;
-    /** Object properties (when type='object') */
-    properties?: Record<string, ISynovaJsonSchema>;
-    /** Required property names (when type='object') */
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: TJsonSchemaFormat;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+    items?: IJsonSchema;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    properties?: Record<string, IJsonSchema>;
     required?: string[];
-    /** Whether additional properties are allowed (when type='object') */
+    additionalProperties?: boolean | IJsonSchema;
+    allOf?: IJsonSchema[];
+    anyOf?: IJsonSchema[];
+    oneOf?: IJsonSchema[];
+    not?: IJsonSchema;
+}
+/**
+ * Metadata keys used by schema decorators
+ */
+declare const SCHEMA_METADATA_KEYS: {
+    readonly DESCRIPTION: "synova:schema:description";
+    readonly EXAMPLES: "synova:schema:examples";
+    readonly DEFAULT: "synova:schema:default";
+    readonly FORMAT: "synova:schema:format";
+    readonly ARRAY_ITEM_TYPE: "synova:schema:arrayItemType";
+    readonly NULLABLE: "synova:schema:nullable";
+    readonly ENUM: "synova:schema:enum";
+    readonly MIN_LENGTH: "synova:schema:minLength";
+    readonly MAX_LENGTH: "synova:schema:maxLength";
+    readonly PATTERN: "synova:schema:pattern";
+    readonly MINIMUM: "synova:schema:minimum";
+    readonly MAXIMUM: "synova:schema:maximum";
+    readonly EXCLUSIVE_MINIMUM: "synova:schema:exclusiveMinimum";
+    readonly EXCLUSIVE_MAXIMUM: "synova:schema:exclusiveMaximum";
+    readonly MULTIPLE_OF: "synova:schema:multipleOf";
+    readonly MIN_ITEMS: "synova:schema:minItems";
+    readonly MAX_ITEMS: "synova:schema:maxItems";
+    readonly UNIQUE_ITEMS: "synova:schema:uniqueItems";
+};
+/**
+ * Options for schema generation
+ */
+interface IGenerateSchemaOptions {
+    /** Allow additional properties on objects (default: false) */
     additionalProperties?: boolean;
 }
+/**
+ * Constructor type for classes
+ */
+type TClassConstructor<T = unknown> = new (...args: any[]) => T;
+
+type TSynovaMessageRole = 'system' | 'user' | 'assistant' | 'tool';
+type TSynovaResponseType = 'message' | 'tool_calls' | 'image' | 'audio' | 'error';
+type TSynovaModelType = 'text' | 'image';
+type TSynovaUsageType = 'tokens' | 'images' | 'time';
 interface ISynovaLogger {
     debug: (message: string, ...args: unknown[]) => void;
     info: (message: string, ...args: unknown[]) => void;
@@ -102,8 +160,10 @@ interface ISynovaExecuteOptions {
     provider: string;
     /** LLM model to use (e.g., 'gpt-4o', 'claude-sonnet-4-20250514') */
     model: string;
-    /** LLM provider key ID to use (if not provided, uses default key for the provider) */
-    apiKeyId?: string;
+    /** Raw API key for the LLM provider */
+    apiKey?: string;
+    /** Azure OpenAI endpoint URL (required for azure_openai provider) */
+    azureEndpoint?: string;
     /** Variables to substitute in prompt template */
     variables?: Record<string, unknown>;
     /** Previous messages for multi-turn conversation */
@@ -117,7 +177,7 @@ interface ISynovaExecuteOptions {
     /** Model parameters (temperature, maxTokens, topP, topK, etc.) */
     parameters?: Record<string, unknown>;
     /** JSON Schema for structured output */
-    responseSchema?: ISynovaJsonSchema;
+    responseSchema?: IJsonSchema;
 }
 interface ISynovaExecutionUsage {
     /** Usage type: 'tokens' for LLM, 'images' for image generation, 'time' for time-based billing */
@@ -144,10 +204,8 @@ interface ISynovaProviderResponse {
 interface ISynovaExecutionErrorDetails {
     /** Model used for the execution */
     model?: string;
-    /** API key ID used for the execution */
-    apiKeyId?: string;
-    /** API key label (human-readable name) */
-    apiKeyLabel?: string;
+    /** Last 5 characters of the API key used (for debugging) */
+    apiKeyHint?: string;
     /** Prompt ID (if execution was via prompt) */
     promptId?: string;
     /** Prompt version (if execution was via prompt) */
@@ -276,49 +334,6 @@ interface ISynovaUploadOptions {
     /** Project ID to associate files with */
     projectId: string;
 }
-type TSynovaLlmProvider = 'openai' | 'anthropic' | 'google' | 'azure_openai' | 'deepseek' | 'replicate' | 'xai' | 'openrouter';
-interface ISynovaAzureConfig {
-    /** Azure OpenAI endpoint URL */
-    endpoint: string;
-}
-interface ISynovaLlmProviderKey {
-    /** Key ID */
-    id: string;
-    /** LLM provider */
-    provider: TSynovaLlmProvider;
-    /** Masked API key (last 4 characters visible) */
-    maskedKey: string;
-    /** Whether this is the default key for the provider */
-    isDefault: boolean;
-    /** Default model for this provider */
-    defaultModel?: string;
-    /** Azure OpenAI configuration */
-    azure?: ISynovaAzureConfig;
-    /** Optional label to identify this key */
-    label?: string;
-    /** Creation date (ISO 8601) */
-    createdAt: string;
-    /** Last update date (ISO 8601) */
-    updatedAt: string;
-}
-interface ISynovaLlmProviderKeyListResponse {
-    items: ISynovaLlmProviderKey[];
-    total: number;
-}
-interface ISynovaCreateLlmProviderKeyOptions {
-    /** LLM provider */
-    provider: TSynovaLlmProvider;
-    /** API key for the LLM provider */
-    apiKey: string;
-    /** Whether this is the default key for the provider */
-    isDefault?: boolean;
-    /** Default model for this provider */
-    defaultModel?: string;
-    /** Azure OpenAI configuration (required for azure_openai provider) */
-    azure?: ISynovaAzureConfig;
-    /** Optional label to identify this key */
-    label?: string;
-}
 interface IApiErrorResponse {
     code: string;
     httpCode: number;
@@ -370,97 +385,82 @@ declare class HttpClient {
     private log;
 }
 
+/**
+ * Execute options with optional responseClass for typed responses
+ */
+interface ISynovaExecuteTypedOptions<T> extends Omit<ISynovaExecuteOptions, 'responseSchema'> {
+    /** Class to use for response typing and schema generation */
+    responseClass: TClassConstructor<T>;
+    /** Enable class-validator validation (default: true) */
+    validate?: boolean;
+}
 declare class PromptsResource {
     private readonly http;
     constructor(http: HttpClient);
     /**
      * Get a prompt by ID (returns version with 'latest' tag)
-     *
-     * @param promptId - The prompt ID (e.g., 'prm_abc123')
-     * @param options - Optional settings
-     * @returns The prompt data
+     */
+    get(promptId: string, options?: ISynovaGetPromptOptions): Promise<ISynovaPrompt>;
+    /**
+     * Execute a prompt with typed response
      *
      * @example
      * ```ts
-     * // Get default (latest) version
-     * const prompt = await client.prompts.get('prm_abc123');
-     *
-     * // Get by specific tag
-     * const production = await client.prompts.get('prm_abc123', { tag: 'production' });
-     *
-     * // Get specific version
-     * const v2 = await client.prompts.get('prm_abc123', { version: '2.0.0' });
+     * // With responseClass - returns typed object
+     * const topic = await client.prompts.execute('prm_abc123', {
+     *   provider: 'openai',
+     *   model: 'gpt-4o',
+     *   responseClass: TopicDto,
+     * });
+     * console.log(topic.title); // Typed as string
      * ```
      */
-    get(promptId: string, options?: ISynovaGetPromptOptions): Promise<ISynovaPrompt>;
+    execute<T>(promptId: string, options: ISynovaExecuteTypedOptions<T>): Promise<T>;
     /**
-     * Execute a prompt with 'latest' tag
-     *
-     * @param promptId - The prompt ID
-     * @param options - Execution options including provider, model and variables
-     * @returns The execution response
+     * Execute a prompt
      *
      * @example
      * ```ts
+     * // Without responseClass - returns ISynovaExecuteResponse
      * const result = await client.prompts.execute('prm_abc123', {
      *   provider: 'openai',
      *   model: 'gpt-4o',
-     *   variables: { topic: 'TypeScript' },
      * });
-     *
      * if (result.type === 'message') {
      *   console.log(result.content);
      * }
-     *
-     * // Image generation
-     * const imageResult = await client.prompts.execute('prm_image123', {
-     *   provider: 'google',
-     *   model: 'gemini-2.0-flash-exp',
-     *   variables: { style: 'modern' },
-     * });
-     *
-     * if (imageResult.type === 'image') {
-     *   console.log('Generated images:', imageResult.files);
-     * }
      * ```
      */
     execute(promptId: string, options: ISynovaExecuteOptions): Promise<ISynovaExecuteResponse>;
+    /**
+     * Execute a prompt by tag with typed response
+     */
+    executeByTag<T>(promptId: string, tag: string, options: ISynovaExecuteTypedOptions<T>): Promise<T>;
     /**
      * Execute a prompt by tag
-     *
-     * @param promptId - The prompt ID
-     * @param tag - The tag (e.g., 'latest', 'production', 'staging')
-     * @param options - Execution options
-     * @returns The execution response
-     *
-     * @example
-     * ```ts
-     * const result = await client.prompts.executeByTag('prm_abc123', 'production', {
-     *   provider: 'openai',
-     *   model: 'gpt-4o',
-     *   variables: { topic: 'TypeScript' },
-     * });
-     * ```
      */
     executeByTag(promptId: string, tag: string, options: ISynovaExecuteOptions): Promise<ISynovaExecuteResponse>;
+    /**
+     * Execute a prompt by version with typed response
+     */
+    executeByVersion<T>(promptId: string, version: string, options: ISynovaExecuteTypedOptions<T>): Promise<T>;
     /**
      * Execute a prompt by version
-     *
-     * @param promptId - The prompt ID
-     * @param version - The semantic version (e.g., '1.0.0', '2.1.0')
-     * @param options - Execution options
-     * @returns The execution response
-     *
-     * @example
-     * ```ts
-     * const result = await client.prompts.executeByVersion('prm_abc123', '1.2.0', {
-     *   provider: 'openai',
-     *   model: 'gpt-4o',
-     *   variables: { topic: 'TypeScript' },
-     * });
-     * ```
      */
     executeByVersion(promptId: string, version: string, options: ISynovaExecuteOptions): Promise<ISynovaExecuteResponse>;
+    /**
+     * Execute raw request without typed response
+     * @throws {ExecutionSynovaError} If LLM returns an error
+     */
+    private executeRaw;
+    /**
+     * Execute with typed response class
+     */
+    private executeTyped;
+    /**
+     * Validate object using class-validator
+     */
+    private validateObject;
 }
 
 declare class ModelsResource {
@@ -556,95 +556,6 @@ declare class FilesResource {
     upload(files: (File | Blob)[], options: ISynovaUploadOptions): Promise<ISynovaUploadResponse>;
 }
 
-declare class LlmProviderKeysResource {
-    private readonly http;
-    constructor(http: HttpClient);
-    /**
-     * List all LLM provider keys
-     *
-     * @returns List of LLM provider keys
-     *
-     * @example
-     * ```ts
-     * const { items, total } = await client.llmProviderKeys.list();
-     * console.log(`Found ${total} keys`);
-     * for (const key of items) {
-     *   console.log(`${key.provider}: ${key.maskedKey} (default: ${key.isDefault})`);
-     * }
-     * ```
-     */
-    list(): Promise<ISynovaLlmProviderKeyListResponse>;
-    /**
-     * Get an LLM provider key by ID
-     *
-     * @param id - Key ID (e.g., 'lpk_abc123')
-     * @returns LLM provider key details
-     *
-     * @example
-     * ```ts
-     * const key = await client.llmProviderKeys.get('lpk_abc123');
-     * console.log(`Provider: ${key.provider}, Default: ${key.isDefault}`);
-     * ```
-     */
-    get(id: string): Promise<ISynovaLlmProviderKey>;
-    /**
-     * Create a new LLM provider key
-     *
-     * The first key created for a provider will automatically be set as the default.
-     *
-     * @param options - Key creation options
-     * @returns Created LLM provider key
-     *
-     * @example
-     * ```ts
-     * // Create OpenAI key
-     * const key = await client.llmProviderKeys.create({
-     *   provider: 'openai',
-     *   apiKey: 'sk-...',
-     *   label: 'Production Key',
-     *   defaultModel: 'gpt-4o',
-     * });
-     *
-     * // Create Azure OpenAI key
-     * const azureKey = await client.llmProviderKeys.create({
-     *   provider: 'azure_openai',
-     *   apiKey: 'your-azure-key',
-     *   azure: {
-     *     endpoint: 'https://my-resource.openai.azure.com',
-     *   },
-     *   label: 'Azure Production',
-     * });
-     * ```
-     */
-    create(options: ISynovaCreateLlmProviderKeyOptions): Promise<ISynovaLlmProviderKey>;
-    /**
-     * Set an LLM provider key as the default for its provider
-     *
-     * The previous default key for this provider will be unset.
-     *
-     * @param id - Key ID to set as default
-     * @returns Updated LLM provider key
-     *
-     * @example
-     * ```ts
-     * const key = await client.llmProviderKeys.setDefault('lpk_abc123');
-     * console.log(`${key.id} is now the default for ${key.provider}`);
-     * ```
-     */
-    setDefault(id: string): Promise<ISynovaLlmProviderKey>;
-    /**
-     * Delete an LLM provider key
-     *
-     * @param id - Key ID to delete
-     *
-     * @example
-     * ```ts
-     * await client.llmProviderKeys.delete('lpk_abc123');
-     * ```
-     */
-    delete(id: string): Promise<void>;
-}
-
 /**
  * Synova Cloud SDK client
  *
@@ -657,10 +568,20 @@ declare class LlmProviderKeysResource {
  * // Get a prompt
  * const prompt = await client.prompts.get('prm_abc123');
  *
- * // Execute a prompt
+ * // Execute a prompt with direct API key
  * const result = await client.prompts.execute('prm_abc123', {
  *   provider: 'openai',
  *   model: 'gpt-4o',
+ *   apiKey: 'sk-...',
+ *   variables: { topic: 'TypeScript' },
+ * });
+ *
+ * // Execute with Azure OpenAI
+ * const azureResult = await client.prompts.execute('prm_abc123', {
+ *   provider: 'azure_openai',
+ *   model: 'gpt-4o',
+ *   apiKey: 'your-azure-key',
+ *   azureEndpoint: 'https://my-resource.openai.azure.com',
  *   variables: { topic: 'TypeScript' },
  * });
  *
@@ -670,14 +591,6 @@ declare class LlmProviderKeysResource {
  * // Get models for a specific provider
  * const openaiModels = await client.models.getByProvider('openai');
  *
- * // Manage LLM provider keys
- * const { items } = await client.llmProviderKeys.list();
- * const newKey = await client.llmProviderKeys.create({
- *   provider: 'openai',
- *   apiKey: 'sk-...',
- *   label: 'Production',
- * });
- *
  * // With custom retry config
  * const clientWithRetry = new SynovaCloudSdk('your-api-key', {
  *   retry: {
@@ -692,7 +605,6 @@ declare class SynovaCloudSdk {
     readonly prompts: PromptsResource;
     readonly models: ModelsResource;
     readonly files: FilesResource;
-    readonly llmProviderKeys: LlmProviderKeysResource;
     private readonly http;
     /**
      * Create a new Synova Cloud SDK client
@@ -763,5 +675,336 @@ declare class NetworkSynovaError extends SynovaError {
     readonly cause?: Error;
     constructor(message: string, cause?: Error);
 }
+/**
+ * Error thrown when LLM execution fails (returned in response with type='error')
+ */
+declare class ExecutionSynovaError extends SynovaError {
+    readonly code: string;
+    readonly provider?: string;
+    readonly retryable: boolean;
+    readonly retryAfterMs?: number;
+    readonly details?: ISynovaExecutionError['details'];
+    constructor(error: ISynovaExecutionError);
+}
+/**
+ * Validation violation details
+ */
+interface IValidationViolation {
+    property: string;
+    constraints: Record<string, string>;
+    value?: unknown;
+}
+/**
+ * Error thrown when LLM response fails class-validator validation
+ */
+declare class ValidationSynovaError extends SynovaError {
+    readonly violations: IValidationViolation[];
+    constructor(violations: IValidationViolation[]);
+}
+
+/**
+ * Generates JSON Schema from TypeScript classes decorated with schema decorators.
+ *
+ * @example
+ * ```typescript
+ * import { ClassSchema, Description, Example, SchemaMin, SchemaMax } from '@synova-cloud/sdk';
+ *
+ * class User {
+ *   @Description('User ID')
+ *   @Example('usr_123')
+ *   id: string;
+ *
+ *   @Description('User age')
+ *   @SchemaMin(0)
+ *   @SchemaMax(150)
+ *   age: number;
+ * }
+ *
+ * const schema = ClassSchema.generate(User);
+ * ```
+ */
+declare class ClassSchema {
+    /**
+     * Generate JSON Schema from a class
+     */
+    static generate<T>(targetClass: TClassConstructor<T>, options?: IGenerateSchemaOptions): IJsonSchema;
+    /**
+     * Get all properties with their schemas
+     */
+    private static getProperties;
+    /**
+     * Get property names from class-validator metadata
+     */
+    private static getClassValidatorProperties;
+    /**
+     * Get property names from our decorator metadata
+     */
+    private static getDecoratorProperties;
+    /**
+     * Get JSON Schema for a single property
+     */
+    private static getPropertySchema;
+    /**
+     * Get base schema from TypeScript type
+     */
+    private static getBaseTypeSchema;
+    /**
+     * Get schema for array items
+     */
+    private static getArrayItemSchema;
+    /**
+     * Apply class-validator constraints to schema
+     */
+    private static applyClassValidatorConstraints;
+    /**
+     * Apply a single class-validator constraint
+     */
+    private static applyValidationConstraint;
+    /**
+     * Apply our decorator metadata to schema.
+     * Our decorators take precedence over class-validator if both are used.
+     */
+    private static applyDecoratorMetadata;
+    /**
+     * Get required properties (properties without @IsOptional)
+     */
+    private static getRequiredProperties;
+}
+
+/**
+ * Adds a description to the property schema.
+ * Helps LLMs understand the expected content.
+ *
+ * @example
+ * ```typescript
+ * class Article {
+ *   @Description('SEO-optimized article title, 50-60 characters')
+ *   title: string;
+ * }
+ * ```
+ */
+declare function Description(description: string): PropertyDecorator;
+/**
+ * Adds example values to the property schema.
+ * Helps LLMs understand the expected format.
+ *
+ * @example
+ * ```typescript
+ * class Article {
+ *   @Example('How to Optimize SQL Queries', '10 Tips for Better Code')
+ *   title: string;
+ * }
+ * ```
+ */
+declare function Example(...examples: unknown[]): PropertyDecorator;
+/**
+ * Sets the default value for the property.
+ *
+ * @example
+ * ```typescript
+ * class Settings {
+ *   @Default('en')
+ *   language: string;
+ * }
+ * ```
+ */
+declare function Default(value: unknown): PropertyDecorator;
+/**
+ * Sets the type of array items.
+ * Required since TypeScript loses array item types at runtime.
+ *
+ * @example
+ * ```typescript
+ * class Article {
+ *   @ArrayItems(String)
+ *   keywords: string[];
+ *
+ *   @ArrayItems(Comment)
+ *   comments: Comment[];
+ * }
+ * ```
+ */
+declare function ArrayItems(itemType: TClassConstructor | StringConstructor | NumberConstructor | BooleanConstructor): PropertyDecorator;
+/**
+ * Sets semantic format for string (email, uri, uuid, date-time, etc.).
+ *
+ * @example
+ * ```typescript
+ * class User {
+ *   @Format('email')
+ *   email: string;
+ *
+ *   @Format('date-time')
+ *   createdAt: string;
+ * }
+ * ```
+ */
+declare function Format(format: TJsonSchemaFormat): PropertyDecorator;
+/**
+ * Marks the property as nullable (can be null).
+ *
+ * @example
+ * ```typescript
+ * class User {
+ *   @Nullable()
+ *   middleName: string | null;
+ * }
+ * ```
+ */
+declare function Nullable(): PropertyDecorator;
+/**
+ * Sets minimum string length.
+ *
+ * @example
+ * ```typescript
+ * class User {
+ *   @SchemaMinLength(3)
+ *   username: string;
+ * }
+ * ```
+ */
+declare function SchemaMinLength(length: number): PropertyDecorator;
+/**
+ * Sets maximum string length.
+ *
+ * @example
+ * ```typescript
+ * class User {
+ *   @SchemaMaxLength(100)
+ *   bio: string;
+ * }
+ * ```
+ */
+declare function SchemaMaxLength(length: number): PropertyDecorator;
+/**
+ * Sets regex pattern for string validation.
+ *
+ * @example
+ * ```typescript
+ * class User {
+ *   @SchemaPattern('^[a-z0-9_]+$')
+ *   username: string;
+ * }
+ * ```
+ */
+declare function SchemaPattern(pattern: string): PropertyDecorator;
+/**
+ * Sets minimum value (inclusive).
+ *
+ * @example
+ * ```typescript
+ * class Product {
+ *   @SchemaMin(0)
+ *   price: number;
+ * }
+ * ```
+ */
+declare function SchemaMin(value: number): PropertyDecorator;
+/**
+ * Sets maximum value (inclusive).
+ *
+ * @example
+ * ```typescript
+ * class Rating {
+ *   @SchemaMax(5)
+ *   score: number;
+ * }
+ * ```
+ */
+declare function SchemaMax(value: number): PropertyDecorator;
+/**
+ * Sets minimum value (exclusive).
+ *
+ * @example
+ * ```typescript
+ * class Discount {
+ *   @ExclusiveMin(0)  // must be > 0
+ *   percentage: number;
+ * }
+ * ```
+ */
+declare function ExclusiveMin(value: number): PropertyDecorator;
+/**
+ * Sets maximum value (exclusive).
+ *
+ * @example
+ * ```typescript
+ * class Probability {
+ *   @ExclusiveMax(1)  // must be < 1
+ *   value: number;
+ * }
+ * ```
+ */
+declare function ExclusiveMax(value: number): PropertyDecorator;
+/**
+ * Value must be a multiple of this number.
+ *
+ * @example
+ * ```typescript
+ * class Currency {
+ *   @MultipleOf(0.01)
+ *   amount: number;
+ * }
+ * ```
+ */
+declare function MultipleOf(value: number): PropertyDecorator;
+/**
+ * Sets minimum array length.
+ *
+ * @example
+ * ```typescript
+ * class Order {
+ *   @SchemaMinItems(1)
+ *   items: OrderItem[];
+ * }
+ * ```
+ */
+declare function SchemaMinItems(count: number): PropertyDecorator;
+/**
+ * Sets maximum array length.
+ *
+ * @example
+ * ```typescript
+ * class Article {
+ *   @SchemaMaxItems(10)
+ *   tags: string[];
+ * }
+ * ```
+ */
+declare function SchemaMaxItems(count: number): PropertyDecorator;
+/**
+ * Requires all array items to be unique.
+ *
+ * @example
+ * ```typescript
+ * class User {
+ *   @SchemaUniqueItems()
+ *   roles: string[];
+ * }
+ * ```
+ */
+declare function SchemaUniqueItems(): PropertyDecorator;
+/**
+ * Sets allowed enum values.
+ *
+ * @example
+ * ```typescript
+ * class User {
+ *   @SchemaEnum(['admin', 'user', 'guest'])
+ *   role: string;
+ * }
+ * ```
+ *
+ * With TypeScript enum:
+ * ```typescript
+ * enum Status { Active = 'active', Inactive = 'inactive' }
+ *
+ * class User {
+ *   @SchemaEnum(Object.values(Status))
+ *   status: Status;
+ * }
+ * ```
+ */
+declare function SchemaEnum(values: (string | number | boolean | null)[]): PropertyDecorator;
 
-export { ApiSynovaError, AuthSynovaError, type ISynovaAzureConfig, type ISynovaConfig, type ISynovaCreateLlmProviderKeyOptions, type ISynovaExecuteOptions, type ISynovaExecuteResponse, type ISynovaExecutionError, type ISynovaExecutionErrorDetails, type ISynovaExecutionUsage, type ISynovaFileAttachment, type ISynovaFileThumbnails, type ISynovaGetPromptOptions, type ISynovaListModelsOptions, type ISynovaLlmProviderKey, type ISynovaLlmProviderKeyListResponse, type ISynovaLogger, type ISynovaMessage, type ISynovaModel, type ISynovaModelCapabilities, type ISynovaModelLimits, type ISynovaModelPricing, type ISynovaModelsResponse, type ISynovaPrompt, type ISynovaPromptVariable, type ISynovaProvider, type ISynovaProviderResponse, type ISynovaRetryConfig, type ISynovaToolCall, type ISynovaToolResult, type ISynovaUploadOptions, type ISynovaUploadResponse, type ISynovaUploadedFile, NetworkSynovaError, NotFoundSynovaError, RateLimitSynovaError, ServerSynovaError, SynovaCloudSdk, SynovaError, type TSynovaLlmProvider, type TSynovaMessageRole, type TSynovaModelType, type TSynovaResponseType, type TSynovaRetryStrategy, type TSynovaUsageType, TimeoutSynovaError };
+export { ApiSynovaError, ArrayItems, AuthSynovaError, ClassSchema, Default, Description, Example, ExclusiveMax, ExclusiveMin, ExecutionSynovaError, Format, type IGenerateSchemaOptions, type IJsonSchema, type ISynovaConfig, type ISynovaExecuteOptions, type ISynovaExecuteResponse, type ISynovaExecuteTypedOptions, type ISynovaExecutionError, type ISynovaExecutionErrorDetails, type ISynovaExecutionUsage, type ISynovaFileAttachment, type ISynovaFileThumbnails, type ISynovaGetPromptOptions, type ISynovaListModelsOptions, type ISynovaLogger, type ISynovaMessage, type ISynovaModel, type ISynovaModelCapabilities, type ISynovaModelLimits, type ISynovaModelPricing, type ISynovaModelsResponse, type ISynovaPrompt, type ISynovaPromptVariable, type ISynovaProvider, type ISynovaProviderResponse, type ISynovaRetryConfig, type ISynovaToolCall, type ISynovaToolResult, type ISynovaUploadOptions, type ISynovaUploadResponse, type ISynovaUploadedFile, type IValidationViolation, MultipleOf, NetworkSynovaError, NotFoundSynovaError, Nullable, RateLimitSynovaError, SCHEMA_METADATA_KEYS, SchemaEnum, SchemaMax, SchemaMaxItems, SchemaMaxLength, SchemaMin, SchemaMinItems, SchemaMinLength, SchemaPattern, SchemaUniqueItems, ServerSynovaError, SynovaCloudSdk, SynovaError, type TClassConstructor, type TJsonSchemaFormat, type TJsonSchemaType, type TSynovaMessageRole, type TSynovaModelType, type TSynovaResponseType, type TSynovaRetryStrategy, type TSynovaUsageType, TimeoutSynovaError, ValidationSynovaError };