@simpleapps-com/augur-api 0.3.2 → 0.4.0

package/dist/esm/services/gregorovich/client.d.ts

@@ -1,6 +1,6 @@
 import { BaseServiceClient } from '../../core/base-client';
 import type { HTTPClient } from '../../core/client';
-import { ChatGptAskRequestParams, ChatGptAskResponse, ChatGptAskResult, DocumentsListResponse, DocumentsListResult, OllamaGenerateRequestParams, OllamaGenerateResult } from './schemas';
+import { ChatGptAskRequestParams, ChatGptAskResponse, ChatGptAskResult, DocumentsResponse, DocumentsResult, OllamaGenerateRequestParams, OllamaGenerateResult } from './schemas';
 /**
  * Gregorovich AI Service Client
  *
@@ -14,323 +14,359 @@ export declare class GregorovichClient extends BaseServiceClient {
     constructor(http: HTTPClient, baseUrl?: string);
     protected getServiceDescription(): string;
     /**
-     * Check service health and availability
-     *
-     * @fullPath api.gregorovich.healthCheck.get
-     * @service gregorovich
-     * @domain system-health
-     * @dataMethod healthCheckData
-     * @discoverable true
-     * @searchTerms ["health", "status", "availability", "ping", "check", "ai service"]
-     * @relatedEndpoints ["api.gregorovich.chatGpt.ask", "api.gregorovich.documents.list", "api.gregorovich.ollama.generate", "api.agrWork.healthCheck.get"]
-     * @commonPatterns ["Health check", "Service status", "AI service availability", "System monitoring"]
-     * @workflow ["system-monitoring", "health-checks", "service-discovery", "ai-service-verification"]
-     * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header"]
-     * @nextSteps ["Use AI endpoints if healthy", "Verify AI service connectivity", "Monitor service metrics"]
-     * @businessRules ["Returns service status and basic info", "Requires standard authentication", "Standard health check format"]
-     * @functionalArea "system-monitoring"
-     * @caching "No caching - real-time status required"
-     * @performance "Fast response, minimal processing, use for AI service monitoring"
-     *
-     * @returns Promise<HealthCheckResponse> Service health status
-     *
-     * @example
-     * ```typescript
-     * // Check if AI service is healthy
-     * const response = await client.healthCheck();
-     * console.log(response.data); // Health status string
-     * console.log(response.status); // HTTP status code
-     *
-     * // Get just the health status
-     * const status = await client.healthCheckData();
-     * console.log(status); // Direct string access
-     * ```
+     * Chat GPT endpoints
+     * OpenAPI Path: /chat-gpt/*
      */
-    readonly healthCheck: () => Promise<{
-        params: Record<string, unknown> | unknown[];
-        data: string;
-        options: Record<string, unknown> | unknown[];
-        status: number;
-        message: string;
-        count: number;
-        total: number;
-        totalResults: number;
-    }>;
-    /**
-     * Ask ChatGPT a question with advanced AI capabilities
-     *
-     * @fullPath api.gregorovich.chatGpt.ask
-     * @service gregorovich
-     * @domain ai-conversation
-     * @dataMethod chatGptAskData
-     * @discoverable true
-     * @searchTerms ["chatgpt", "ai", "question", "ask", "conversation", "gpt", "openai", "assistant", "chat"]
-     * @relatedEndpoints ["api.gregorovich.ollama.generate", "api.gregorovich.documents.list", "api.agrSite.ai.transcripts.create", "api.p21Pim.ai.suggestions.get"]
-     * @commonPatterns ["Ask AI question", "Get AI assistance", "Conversational AI", "AI-powered help", "Question answering", "AI consultation"]
-     * @workflow ["ai-conversation", "customer-support", "content-generation", "decision-support", "knowledge-retrieval"]
-     * @prerequisites ["Valid authentication token", "x-site-id header", "Question parameter", "ChatGPT service availability"]
-     * @nextSteps ["Process AI response", "Continue conversation", "Store conversation history", "Analyze AI recommendations"]
-     * @businessRules ["Requires question parameter", "Supports conversation context", "Token usage tracking", "Response quality metrics", "Configurable AI parameters"]
-     * @functionalArea "ai-and-automation"
-     * @crossSite "Multi-site AI conversation support"
-     * @caching "Cache responses for 1 hour for identical questions, AI responses are generally stable"
-     * @performance "Response time varies by question complexity, use streaming for long responses"
-     *
-     * @param params ChatGPT question parameters including question text and AI configuration options
-     * @returns Promise<ChatGptAskResponse> Complete AI response with answer, metadata, and usage information
-     *
-     * @example
-     * ```typescript
-     * // Ask a simple question
-     * const aiResponse = await client.chatGptAsk({ question: 'What is the weather like today?' });
-     * console.log(aiResponse.data.answer); // AI generated answer
-     * console.log(aiResponse.data.tokens); // Token usage information
-     *
-     * // Get just the AI answer
-     * const answer = await client.chatGptAskData({ question: 'Explain quantum computing' });
-     * console.log(answer.answer); // Direct access to AI response
-     *
-     * // Advanced AI configuration
-     * const complexRequest = {
-     *   question: 'Write a business plan for a tech startup',
-     *   temperature: 0.7,
-     *   maxTokens: 2000,
-     *   format: 'markdown' as const,
-     *   systemPrompt: 'You are a business consultant with 20 years of experience',
-     *   conversationId: 'conv-123',
-     *   language: 'english'
-     * };
-     *
-     * const businessPlan = await client.chatGptAskData(complexRequest);
-     * console.log(businessPlan.answer); // Detailed business plan
-     * console.log(businessPlan.usage); // Token usage breakdown
-     *
-     * // Continue a conversation
-     * const followUp = await client.chatGptAskData({
-     *   question: 'Can you expand on the marketing strategy section?',
-     *   conversationId: 'conv-123',
-     *   temperature: 0.5
-     * });
-     * ```
-     */
-    readonly chatGptAsk: (params: ChatGptAskRequestParams) => Promise<ChatGptAskResponse>;
-    /**
-     * List available documents in the AI knowledge base
-     *
-     * @fullPath api.gregorovich.documents.list
-     * @service gregorovich
-     * @domain document-management
-     * @dataMethod documentsListData
-     * @discoverable true
-     * @searchTerms ["documents", "files", "knowledge", "library", "content", "resources", "papers", "manuals"]
-     * @relatedEndpoints ["api.gregorovich.chatGpt.ask", "api.joomla.content.list", "api.agrSite.content.search", "api.items.faq.list"]
-     * @commonPatterns ["List documents", "Browse knowledge base", "Find resources", "Document library", "Content discovery", "Knowledge management"]
-     * @workflow ["document-discovery", "knowledge-management", "research", "content-organization", "ai-training-data"]
-     * @prerequisites ["Public bearer token", "x-site-id header", "Document access permissions"]
-     * @nextSteps ["Select document for AI processing", "Use document content for AI questions", "Organize document library", "Analyze document metadata"]
-     * @businessRules ["Returns accessible documents only", "Supports document filtering", "Includes metadata and status", "Permissions-based access", "Searchable content"]
-     * @functionalArea "content-and-knowledge-management"
-     * @crossSite "Multi-site document library support"
-     * @caching "Cache for 15 minutes, document lists change infrequently"
-     * @performance "Optimize with pagination for large document sets, supports filtering and search"
-     *
-     * @returns Promise<DocumentsListResponse> Complete list of available documents with metadata and organization information
-     *
-     * @example
-     * ```typescript
-     * // List all available documents
-     * const docsResponse = await client.documentsList();
-     * console.log(docsResponse.data); // Array of document objects
-     * console.log(docsResponse.total); // Total document count
-     *
-     * // Get just the documents array
-     * const documents = await client.documentsListData();
-     * console.log(documents); // Direct access to document array
-     *
-     * // Process document library
-     * const docs = await client.documentsListData();
-     * const publishedDocs = docs.filter(doc => doc.status === 'published');
-     * const categories = [...new Set(docs.map(doc => doc.category))];
-     *
-     * console.log(`Found ${publishedDocs.length} published documents`);
-     * console.log(`Available categories: ${categories.join(', ')}`);
-     *
-     * // Find specific document types
-     * const manuals = docs.filter(doc =>
-     *   doc.type === 'manual' || doc.tags?.includes('manual')
-     * );
-     * const recentDocs = docs.filter(doc =>
-     *   new Date(doc.updatedAt || 0) > new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
-     * );
-     * ```
-     */
-    readonly documentsList: () => Promise<DocumentsListResponse>;
-    /**
-     * Generate content using local Ollama AI models
-     *
-     * @fullPath api.gregorovich.ollama.generate
-     * @service gregorovich
-     * @domain ai-generation
-     * @dataMethod ollamaGenerateData
-     * @discoverable true
-     * @searchTerms ["ollama", "generate", "ai", "local", "llm", "model", "text", "completion", "generation"]
-     * @relatedEndpoints ["api.gregorovich.chatGpt.ask", "api.p21Pim.ai.suggestions.get", "api.agrSite.ai.transcripts.create", "api.gregorovich.documents.list"]
-     * @commonPatterns ["Generate AI content", "Local AI processing", "Text completion", "AI writing assistant", "Custom model inference", "Private AI generation"]
-     * @workflow ["content-generation", "ai-assistance", "text-processing", "creative-writing", "code-generation", "document-analysis"]
-     * @prerequisites ["Public bearer token", "x-site-id header", "Model name", "Generation prompt", "Ollama service availability"]
-     * @nextSteps ["Process generated content", "Refine generation parameters", "Chain multiple generations", "Store generation results"]
-     * @businessRules ["Requires model and prompt parameters", "Supports local model execution", "Configurable generation parameters", "Token and context management", "Performance monitoring"]
-     * @functionalArea "ai-and-automation"
-     * @crossSite "Multi-site AI generation support"
-     * @caching "Cache responses for 30 minutes for identical prompts and parameters"
-     * @performance "Local processing, faster than external APIs but depends on model size and complexity"
-     *
-     * @param params Ollama generation parameters including model, prompt, and generation configuration
-     * @returns Promise<OllamaGenerateResponse> Complete AI generation result with content, metadata, and performance metrics
-     *
-     * @example
-     * ```typescript
-     * // Simple text generation
-     * const generation = await client.ollamaGenerate({
-     *   model: 'llama2',
-     *   prompt: 'Write a short story about a robot learning to paint'
-     * });
-     * console.log(generation.data.response); // Generated story
-     * console.log(generation.data.total_duration); // Generation time
-     *
-     * // Get just the generated content
-     * const story = await client.ollamaGenerateData({
-     *   model: 'codellama',
-     *   prompt: 'Create a Python function to calculate fibonacci numbers'
-     * });
-     * console.log(story.response); // Direct access to generated code
-     *
-     * // Advanced generation with parameters
-     * const technicalDoc = await client.ollamaGenerateData({
-     *   model: 'mistral',
-     *   prompt: 'Explain machine learning algorithms for beginners',
-     *   temperature: 0.3,
-     *   max_tokens: 1500,
-     *   system: 'You are a patient teacher who explains complex topics simply',
-     *   format: 'json',
-     *   top_p: 0.9,
-     *   seed: 42
-     * });
-     *
-     * // Creative writing with higher randomness
-     * const creativeContent = await client.ollamaGenerateData({
-     *   model: 'neural-chat',
-     *   prompt: 'Write a product description for a smart home device',
-     *   temperature: 0.8,
-     *   top_k: 40,
-     *   repeat_penalty: 1.1,
-     *   stop: ['\\n\\n', 'END'],
-     *   sessionId: 'creative-session-1'
-     * });
-     *
-     * // Conversation with context
-     * const conversational = await client.ollamaGenerateData({
-     *   model: 'llama2-chat',
-     *   prompt: 'What are the benefits of renewable energy?',
-     *   context: previousContext, // Array of context tokens
-     *   conversationId: 'energy-discussion',
-     *   num_predict: 200
-     * });
-     * ```
-     */
-    readonly ollamaGenerate: (data: import("zod").objectInputType<{
-        model: import("zod").ZodString;
-        prompt: import("zod").ZodString;
-        temperature: import("zod").ZodOptional<import("zod").ZodNumber>;
-        top_p: import("zod").ZodOptional<import("zod").ZodNumber>;
-        top_k: import("zod").ZodOptional<import("zod").ZodNumber>;
-        repeat_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
-        seed: import("zod").ZodOptional<import("zod").ZodNumber>;
-        max_tokens: import("zod").ZodOptional<import("zod").ZodNumber>;
-        stop: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
-        stream: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        context: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
-        system: import("zod").ZodOptional<import("zod").ZodString>;
-        template: import("zod").ZodOptional<import("zod").ZodString>;
-        format: import("zod").ZodOptional<import("zod").ZodEnum<["json", "text"]>>;
-        raw: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        keep_alive: import("zod").ZodOptional<import("zod").ZodString>;
-        num_predict: import("zod").ZodOptional<import("zod").ZodNumber>;
-        num_ctx: import("zod").ZodOptional<import("zod").ZodNumber>;
-        num_batch: import("zod").ZodOptional<import("zod").ZodNumber>;
-        num_gpu: import("zod").ZodOptional<import("zod").ZodNumber>;
-        main_gpu: import("zod").ZodOptional<import("zod").ZodNumber>;
-        low_vram: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        f16_kv: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        vocab_only: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        use_mmap: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        use_mlock: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        embedding_only: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        numa: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        sessionId: import("zod").ZodOptional<import("zod").ZodString>;
-        conversationId: import("zod").ZodOptional<import("zod").ZodString>;
-        userId: import("zod").ZodOptional<import("zod").ZodString>;
-        tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
-        priority: import("zod").ZodOptional<import("zod").ZodEnum<["low", "normal", "high"]>>;
-    }, import("zod").ZodTypeAny, "passthrough">) => Promise<{
-        params: Record<string, unknown> | unknown[];
-        data: {
-            status?: "timeout" | "success" | "error" | "partial" | undefined;
-            response?: string | undefined;
-            timestamp?: string | undefined;
-            requestId?: string | undefined;
-            sessionId?: string | undefined;
-            version?: string | undefined;
-            warnings?: string[] | undefined;
-            model?: string | undefined;
-            context?: number[] | undefined;
-            error?: string | undefined;
-            created_at?: string | undefined;
-            conversationId?: string | undefined;
-            messageId?: string | undefined;
-            done?: boolean | undefined;
-            total_duration?: number | undefined;
-            load_duration?: number | undefined;
-            prompt_eval_count?: number | undefined;
-            prompt_eval_duration?: number | undefined;
-            eval_count?: number | undefined;
-            eval_duration?: number | undefined;
-            finish_reason?: string | undefined;
-            prompt_tokens?: number | undefined;
-            completion_tokens?: number | undefined;
-            total_tokens?: number | undefined;
-            capabilities?: string[] | undefined;
-        } & {
-            [k: string]: unknown;
+    readonly chatGpt: {
+        /**
+         * Ask endpoints
+         * OpenAPI Path: /chat-gpt/ask
+         */
+        ask: {
+            /**
+             * Ask ChatGPT a question with advanced AI capabilities
+             *
+             * @fullPath api.gregorovich.chatGpt.ask.get
+             * @service gregorovich
+             * @domain ai-conversation
+             * @dataMethod chatGptAskData
+             * @discoverable true
+             * @searchTerms ["chatgpt", "ai", "question", "ask", "conversation", "gpt", "openai", "assistant", "chat"]
+             * @relatedEndpoints ["api.gregorovich.ollama.generate.create", "api.gregorovich.documents.list", "api.agrSite.ai.transcripts.create", "api.p21Pim.ai.suggestions.get"]
+             * @commonPatterns ["Ask AI question", "Get AI assistance", "Conversational AI", "AI-powered help", "Question answering", "AI consultation"]
+             * @workflow ["ai-conversation", "customer-support", "content-generation", "decision-support", "knowledge-retrieval"]
+             * @prerequisites ["Valid authentication token", "x-site-id header", "Question parameter", "ChatGPT service availability"]
+             * @nextSteps ["Process AI response", "Continue conversation", "Store conversation history", "Analyze AI recommendations"]
+             * @businessRules ["Requires question parameter", "Supports conversation context", "Token usage tracking", "Response quality metrics", "Configurable AI parameters"]
+             * @functionalArea "ai-and-automation"
+             * @crossSite "Multi-site AI conversation support"
+             * @caching "Cache responses for 1 hour for identical questions, AI responses are generally stable"
+             * @performance "Response time varies by question complexity, use streaming for long responses"
+             *
+             * @param params ChatGPT question parameters including question text and AI configuration options
+             * @returns Promise<ChatGptAskResponse> Complete AI response with answer, metadata, and usage information
+             *
+             * @example
+             * ```typescript
+             * // Ask a simple question
+             * const aiResponse = await client.chatGpt.ask.get({ question: 'What is the weather like today?' });
+             * console.log(aiResponse.data.answer); // AI generated answer
+             * console.log(aiResponse.data.tokens); // Token usage information
+             *
+             * // Get just the AI answer
+             * const answer = await client.chatGpt.ask.getData({ question: 'Explain quantum computing' });
+             * console.log(answer.answer); // Direct access to AI response
+             *
+             * // Advanced AI configuration
+             * const complexRequest = {
+             *   question: 'Write a business plan for a tech startup',
+             *   temperature: 0.7,
+             *   maxTokens: 2000,
+             *   format: 'markdown' as const,
+             *   systemPrompt: 'You are a business consultant with 20 years of experience',
+             *   conversationId: 'conv-123',
+             *   language: 'english'
+             * };
+             *
+             * const businessPlan = await client.chatGpt.ask.getData(complexRequest);
+             * console.log(businessPlan.answer); // Detailed business plan
+             * console.log(businessPlan.usage); // Token usage breakdown
+             *
+             * // Continue a conversation
+             * const followUp = await client.chatGpt.ask.getData({
+             *   question: 'Can you expand on the marketing strategy section?',
+             *   conversationId: 'conv-123',
+             *   temperature: 0.5
+             * });
+             * ```
+             */
+            get: (params: ChatGptAskRequestParams) => Promise<ChatGptAskResponse>;
+            /**
+             * Ask ChatGPT a question and return AI response data only
+             * @param params ChatGPT question parameters
+             * @returns Promise<ChatGptAskResult> AI response with answer and metadata
+             */
+            getData: (params: ChatGptAskRequestParams) => Promise<ChatGptAskResult>;
         };
-        options: Record<string, unknown> | unknown[];
-        status: number;
-        message: string;
-        count: number;
-        total: number;
-        totalResults: number;
-    }>;
-    /**
-     * Get health check status data only
-     * @returns Promise<string> Health status string
-     */
-    readonly healthCheckData: () => Promise<string>;
+    };
     /**
-     * Ask ChatGPT a question and return AI response data only
-     * @param params ChatGPT question parameters
-     * @returns Promise<ChatGptAskResult> AI response with answer and metadata
+     * Documents endpoints
+     * OpenAPI Path: /documents
      */
-    readonly chatGptAskData: (params: ChatGptAskRequestParams) => Promise<ChatGptAskResult>;
+    readonly documents: {
+        /**
+         * List available documents in the AI knowledge base
+         *
+         * @fullPath api.gregorovich.documents.list
+         * @service gregorovich
+         * @domain document-management
+         * @dataMethod documentsData
+         * @discoverable true
+         * @searchTerms ["documents", "files", "knowledge", "library", "content", "resources", "papers", "manuals"]
+         * @relatedEndpoints ["api.gregorovich.chatGpt.ask.get", "api.joomla.content.list", "api.agrSite.content.search", "api.items.faq.list"]
+         * @commonPatterns ["List documents", "Browse knowledge base", "Find resources", "Document library", "Content discovery", "Knowledge management"]
+         * @workflow ["document-discovery", "knowledge-management", "research", "content-organization", "ai-training-data"]
+         * @prerequisites ["Public bearer token", "x-site-id header", "Document access permissions"]
+         * @nextSteps ["Select document for AI processing", "Use document content for AI questions", "Organize document library", "Analyze document metadata"]
+         * @businessRules ["Returns accessible documents only", "Supports document filtering", "Includes metadata and status", "Permissions-based access", "Searchable content"]
+         * @functionalArea "content-and-knowledge-management"
+         * @crossSite "Multi-site document library support"
+         * @caching "Cache for 15 minutes, document lists change infrequently"
+         * @performance "Optimize with pagination for large document sets, supports filtering and search"
+         *
+         * @returns Promise<DocumentsResponse> Complete list of available documents with metadata and organization information
+         *
+         * @example
+         * ```typescript
+         * // List all available documents
+         * const docsResponse = await client.documents.list();
+         * console.log(docsResponse.data); // Array of document objects
+         * console.log(docsResponse.total); // Total document count
+         *
+         * // Get just the documents array
+         * const documents = await client.documents.getData();
+         * console.log(documents); // Direct access to document array
+         *
+         * // Process document library
+         * const docs = await client.documents.getData();
+         * const publishedDocs = docs.filter(doc => doc.status === 'published');
+         * const categories = [...new Set(docs.map(doc => doc.category))];
+         *
+         * console.log(`Found ${publishedDocs.length} published documents`);
+         * console.log(`Available categories: ${categories.join(', ')}`);
+         *
+         * // Find specific document types
+         * const manuals = docs.filter(doc =>
+         *   doc.type === 'manual' || doc.tags?.includes('manual')
+         * );
+         * const recentDocs = docs.filter(doc =>
+         *   new Date(doc.updatedAt || 0) > new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
+         * );
+         * ```
+         */
+        list: () => Promise<DocumentsResponse>;
+        /**
+         * List documents and return documents array data only
+         * @returns Promise<DocumentsResult[]> Array of document objects
+         */
+        getData: () => Promise<DocumentsResult[]>;
+    };
     /**
-     * List documents and return documents array data only
-     * @returns Promise<DocumentsListResult[]> Array of document objects
+     * Health Check endpoints
+     * OpenAPI Path: /health-check
      */
-    readonly documentsListData: () => Promise<DocumentsListResult[]>;
+    readonly healthCheck: {
+        /**
+         * Check service health and availability
+         *
+         * @fullPath api.gregorovich.healthCheck.get
+         * @service gregorovich
+         * @domain system-health
+         * @dataMethod healthCheckData
+         * @discoverable true
+         * @searchTerms ["health", "status", "availability", "ping", "check", "ai service"]
+         * @relatedEndpoints ["api.gregorovich.chatGpt.ask.get", "api.gregorovich.documents.list", "api.gregorovich.ollama.generate.create", "api.agrWork.healthCheck.get"]
+         * @commonPatterns ["Health check", "Service status", "AI service availability", "System monitoring"]
+         * @workflow ["system-monitoring", "health-checks", "service-discovery", "ai-service-verification"]
+         * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header"]
+         * @nextSteps ["Use AI endpoints if healthy", "Verify AI service connectivity", "Monitor service metrics"]
+         * @businessRules ["Returns service status and basic info", "Requires standard authentication", "Standard health check format"]
+         * @functionalArea "system-monitoring"
+         * @caching "No caching - real-time status required"
+         * @performance "Fast response, minimal processing, use for AI service monitoring"
+         *
+         * @returns Promise<HealthCheckResponse> Service health status
+         *
+         * @example
+         * ```typescript
+         * // Check if AI service is healthy
+         * const response = await client.healthCheck.get();
+         * console.log(response.data); // Health status string
+         * console.log(response.status); // HTTP status code
+         *
+         * // Get just the health status
+         * const status = await client.healthCheck.getData();
+         * console.log(status); // Direct string access
+         * ```
+         */
+        get: () => Promise<{
+            params: Record<string, unknown> | unknown[];
+            data: string;
+            options: Record<string, unknown> | unknown[];
+            status: number;
+            message: string;
+            count: number;
+            total: number;
+            totalResults: number;
+        }>;
+        /**
+         * Get health check status data only
+         * @returns Promise<string> Health status string
+         */
+        getData: () => Promise<string>;
+    };
     /**
-     * Generate content with Ollama and return generation result data only
-     * @param params Ollama generation parameters
-     * @returns Promise<OllamaGenerateResult> Generated content with metadata and performance metrics
+     * Ollama endpoints
+     * OpenAPI Path: /ollama/*
      */
-    readonly ollamaGenerateData: (params: OllamaGenerateRequestParams) => Promise<OllamaGenerateResult>;
+    readonly ollama: {
+        /**
+         * Generate endpoints
+         * OpenAPI Path: /ollama/generate
+         */
+        generate: {
+            /**
+             * Generate content using local Ollama AI models
+             *
+             * @fullPath api.gregorovich.ollama.generate.create
+             * @service gregorovich
+             * @domain ai-generation
+             * @dataMethod ollamaGenerateData
+             * @discoverable true
+             * @searchTerms ["ollama", "generate", "ai", "local", "llm", "model", "text", "completion", "generation"]
+             * @relatedEndpoints ["api.gregorovich.chatGpt.ask.get", "api.p21Pim.ai.suggestions.get", "api.agrSite.ai.transcripts.create", "api.gregorovich.documents.list"]
+             * @commonPatterns ["Generate AI content", "Local AI processing", "Text completion", "AI writing assistant", "Custom model inference", "Private AI generation"]
+             * @workflow ["content-generation", "ai-assistance", "text-processing", "creative-writing", "code-generation", "document-analysis"]
+             * @prerequisites ["Public bearer token", "x-site-id header", "Model name", "Generation prompt", "Ollama service availability"]
+             * @nextSteps ["Process generated content", "Refine generation parameters", "Chain multiple generations", "Store generation results"]
+             * @businessRules ["Requires model and prompt parameters", "Supports local model execution", "Configurable generation parameters", "Token and context management", "Performance monitoring"]
+             * @functionalArea "ai-and-automation"
+             * @crossSite "Multi-site AI generation support"
+             * @caching "Cache responses for 30 minutes for identical prompts and parameters"
+             * @performance "Local processing, faster than external APIs but depends on model size and complexity"
+             *
+             * @param params Ollama generation parameters including model, prompt, and generation configuration
+             * @returns Promise<OllamaGenerateResponse> Complete AI generation result with content, metadata, and performance metrics
+             *
+             * @example
+             * ```typescript
+             * // Simple text generation
+             * const generation = await client.ollama.generate.create({
+             *   model: 'llama2',
+             *   prompt: 'Write a short story about a robot learning to paint'
+             * });
+             * console.log(generation.data.response); // Generated story
+             * console.log(generation.data.total_duration); // Generation time
+             *
+             * // Get just the generated content
+             * const story = await client.ollama.generate.getData({
+             *   model: 'codellama',
+             *   prompt: 'Create a Python function to calculate fibonacci numbers'
+             * });
+             * console.log(story.response); // Direct access to generated code
+             *
+             * // Advanced generation with parameters
+             * const technicalDoc = await client.ollama.generate.getData({
+             *   model: 'mistral',
+             *   prompt: 'Explain machine learning algorithms for beginners',
+             *   temperature: 0.3,
+             *   max_tokens: 1500,
+             *   system: 'You are a patient teacher who explains complex topics simply',
+             *   format: 'json',
+             *   top_p: 0.9,
+             *   seed: 42
+             * });
+             *
+             * // Creative writing with higher randomness
+             * const creativeContent = await client.ollama.generate.getData({
+             *   model: 'neural-chat',
+             *   prompt: 'Write a product description for a smart home device',
+             *   temperature: 0.8,
+             *   top_k: 40,
+             *   repeat_penalty: 1.1,
+             *   stop: ['\\n\\n', 'END'],
+             *   sessionId: 'creative-session-1'
+             * });
+             *
+             * // Conversation with context
+             * const conversational = await client.ollama.generate.getData({
+             *   model: 'llama2-chat',
+             *   prompt: 'What are the benefits of renewable energy?',
+             *   context: previousContext, // Array of context tokens
+             *   conversationId: 'energy-discussion',
+             *   num_predict: 200
+             * });
+             * ```
+             */
+            create: (data: import("zod").objectInputType<{
+                model: import("zod").ZodString;
+                prompt: import("zod").ZodString;
+                temperature: import("zod").ZodOptional<import("zod").ZodNumber>;
+                top_p: import("zod").ZodOptional<import("zod").ZodNumber>;
+                top_k: import("zod").ZodOptional<import("zod").ZodNumber>;
+                repeat_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+                seed: import("zod").ZodOptional<import("zod").ZodNumber>;
+                max_tokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+                stop: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                stream: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                context: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
+                system: import("zod").ZodOptional<import("zod").ZodString>;
+                template: import("zod").ZodOptional<import("zod").ZodString>;
+                format: import("zod").ZodOptional<import("zod").ZodEnum<["json", "text"]>>;
+                raw: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                keep_alive: import("zod").ZodOptional<import("zod").ZodString>;
+                num_predict: import("zod").ZodOptional<import("zod").ZodNumber>;
+                num_ctx: import("zod").ZodOptional<import("zod").ZodNumber>;
+                num_batch: import("zod").ZodOptional<import("zod").ZodNumber>;
+                num_gpu: import("zod").ZodOptional<import("zod").ZodNumber>;
+                main_gpu: import("zod").ZodOptional<import("zod").ZodNumber>;
+                low_vram: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                f16_kv: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                vocab_only: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                use_mmap: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                use_mlock: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                embedding_only: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                numa: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                sessionId: import("zod").ZodOptional<import("zod").ZodString>;
+                conversationId: import("zod").ZodOptional<import("zod").ZodString>;
+                userId: import("zod").ZodOptional<import("zod").ZodString>;
+                tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                priority: import("zod").ZodOptional<import("zod").ZodEnum<["low", "normal", "high"]>>;
+            }, import("zod").ZodTypeAny, "passthrough">) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    status?: "timeout" | "success" | "partial" | "error" | undefined;
+                    response?: string | undefined;
+                    timestamp?: string | undefined;
+                    requestId?: string | undefined;
+                    sessionId?: string | undefined;
+                    version?: string | undefined;
+                    warnings?: string[] | undefined;
+                    model?: string | undefined;
+                    created_at?: string | undefined;
+                    conversationId?: string | undefined;
+                    messageId?: string | undefined;
+                    context?: number[] | undefined;
+                    done?: boolean | undefined;
+                    total_duration?: number | undefined;
+                    load_duration?: number | undefined;
+                    prompt_eval_count?: number | undefined;
+                    prompt_eval_duration?: number | undefined;
+                    eval_count?: number | undefined;
+                    eval_duration?: number | undefined;
+                    finish_reason?: string | undefined;
+                    prompt_tokens?: number | undefined;
+                    completion_tokens?: number | undefined;
+                    total_tokens?: number | undefined;
+                    capabilities?: string[] | undefined;
+                    error?: string | undefined;
+                } & {
+                    [k: string]: unknown;
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * Generate content with Ollama and return generation result data only
+             * @param params Ollama generation parameters
+             * @returns Promise<OllamaGenerateResult> Generated content with metadata and performance metrics
+             */
+            getData: (params: OllamaGenerateRequestParams) => Promise<OllamaGenerateResult>;
+        };
+    };
 }
 //# sourceMappingURL=client.d.ts.map