@simpleapps-com/augur-api 0.2.13 → 0.3.1

package/dist/types/services/customers/schemas/contacts.d.ts

@@ -50,8 +50,8 @@ export declare const ContactSchema: z.ZodObject<{
         canPlaceOrders?: boolean | undefined;
         canViewInvoices?: boolean | undefined;
     } | undefined;
-    phoneNumber?: string | undefined;
     isPrimary?: boolean | undefined;
+    phoneNumber?: string | undefined;
     webEnabled?: boolean | undefined;
     loginCredentials?: {
         username?: string | undefined;
@@ -72,8 +72,8 @@ export declare const ContactSchema: z.ZodObject<{
         canPlaceOrders?: boolean | undefined;
         canViewInvoices?: boolean | undefined;
     } | undefined;
-    phoneNumber?: string | undefined;
     isPrimary?: boolean | undefined;
+    phoneNumber?: string | undefined;
     webEnabled?: boolean | undefined;
     loginCredentials?: {
         username?: string | undefined;
@@ -113,8 +113,8 @@ export declare const ContactCreateParamsSchema: z.ZodObject<{
         canPlaceOrders?: boolean | undefined;
         canViewInvoices?: boolean | undefined;
     } | undefined;
-    phoneNumber?: string | undefined;
     isPrimary?: boolean | undefined;
+    phoneNumber?: string | undefined;
     webEnabled?: boolean | undefined;
 }, {
     email: string;
@@ -127,8 +127,8 @@ export declare const ContactCreateParamsSchema: z.ZodObject<{
         canPlaceOrders?: boolean | undefined;
         canViewInvoices?: boolean | undefined;
     } | undefined;
-    phoneNumber?: string | undefined;
     isPrimary?: boolean | undefined;
+    phoneNumber?: string | undefined;
     webEnabled?: boolean | undefined;
 }>;
 export declare const ContactListParamsSchema: z.ZodObject<{
@@ -267,8 +267,8 @@ export declare const ContactListResponseSchema: z.ZodEffects<z.ZodObject<{
             canPlaceOrders?: boolean | undefined;
             canViewInvoices?: boolean | undefined;
         } | undefined;
-        phoneNumber?: string | undefined;
         isPrimary?: boolean | undefined;
+        phoneNumber?: string | undefined;
         webEnabled?: boolean | undefined;
         loginCredentials?: {
             username?: string | undefined;
@@ -289,8 +289,8 @@ export declare const ContactListResponseSchema: z.ZodEffects<z.ZodObject<{
             canPlaceOrders?: boolean | undefined;
             canViewInvoices?: boolean | undefined;
         } | undefined;
-        phoneNumber?: string | undefined;
         isPrimary?: boolean | undefined;
+        phoneNumber?: string | undefined;
         webEnabled?: boolean | undefined;
         loginCredentials?: {
             username?: string | undefined;
@@ -320,8 +320,8 @@ export declare const ContactListResponseSchema: z.ZodEffects<z.ZodObject<{
             canPlaceOrders?: boolean | undefined;
             canViewInvoices?: boolean | undefined;
         } | undefined;
-        phoneNumber?: string | undefined;
         isPrimary?: boolean | undefined;
+        phoneNumber?: string | undefined;
         webEnabled?: boolean | undefined;
         loginCredentials?: {
             username?: string | undefined;
@@ -351,8 +351,8 @@ export declare const ContactListResponseSchema: z.ZodEffects<z.ZodObject<{
             canPlaceOrders?: boolean | undefined;
             canViewInvoices?: boolean | undefined;
         } | undefined;
-        phoneNumber?: string | undefined;
         isPrimary?: boolean | undefined;
+        phoneNumber?: string | undefined;
         webEnabled?: boolean | undefined;
         loginCredentials?: {
             username?: string | undefined;
@@ -382,8 +382,8 @@ export declare const ContactListResponseSchema: z.ZodEffects<z.ZodObject<{
             canPlaceOrders?: boolean | undefined;
             canViewInvoices?: boolean | undefined;
         } | undefined;
-        phoneNumber?: string | undefined;
         isPrimary?: boolean | undefined;
+        phoneNumber?: string | undefined;
         webEnabled?: boolean | undefined;
         loginCredentials?: {
             username?: string | undefined;
@@ -413,8 +413,8 @@ export declare const ContactListResponseSchema: z.ZodEffects<z.ZodObject<{
             canPlaceOrders?: boolean | undefined;
             canViewInvoices?: boolean | undefined;
         } | undefined;
-        phoneNumber?: string | undefined;
         isPrimary?: boolean | undefined;
+        phoneNumber?: string | undefined;
         webEnabled?: boolean | undefined;
         loginCredentials?: {
             username?: string | undefined;
@@ -481,8 +481,8 @@ export declare const ContactResponseSchema: z.ZodEffects<z.ZodObject<{
             canPlaceOrders?: boolean | undefined;
             canViewInvoices?: boolean | undefined;
         } | undefined;
-        phoneNumber?: string | undefined;
         isPrimary?: boolean | undefined;
+        phoneNumber?: string | undefined;
         webEnabled?: boolean | undefined;
         loginCredentials?: {
             username?: string | undefined;
@@ -503,8 +503,8 @@ export declare const ContactResponseSchema: z.ZodEffects<z.ZodObject<{
             canPlaceOrders?: boolean | undefined;
             canViewInvoices?: boolean | undefined;
         } | undefined;
-        phoneNumber?: string | undefined;
         isPrimary?: boolean | undefined;
+        phoneNumber?: string | undefined;
         webEnabled?: boolean | undefined;
         loginCredentials?: {
             username?: string | undefined;
@@ -534,8 +534,8 @@ export declare const ContactResponseSchema: z.ZodEffects<z.ZodObject<{
             canPlaceOrders?: boolean | undefined;
             canViewInvoices?: boolean | undefined;
         } | undefined;
-        phoneNumber?: string | undefined;
         isPrimary?: boolean | undefined;
+        phoneNumber?: string | undefined;
         webEnabled?: boolean | undefined;
         loginCredentials?: {
             username?: string | undefined;
@@ -565,8 +565,8 @@ export declare const ContactResponseSchema: z.ZodEffects<z.ZodObject<{
             canPlaceOrders?: boolean | undefined;
             canViewInvoices?: boolean | undefined;
         } | undefined;
-        phoneNumber?: string | undefined;
         isPrimary?: boolean | undefined;
+        phoneNumber?: string | undefined;
         webEnabled?: boolean | undefined;
         loginCredentials?: {
             username?: string | undefined;
@@ -596,8 +596,8 @@ export declare const ContactResponseSchema: z.ZodEffects<z.ZodObject<{
             canPlaceOrders?: boolean | undefined;
             canViewInvoices?: boolean | undefined;
         } | undefined;
-        phoneNumber?: string | undefined;
         isPrimary?: boolean | undefined;
+        phoneNumber?: string | undefined;
         webEnabled?: boolean | undefined;
         loginCredentials?: {
             username?: string | undefined;
@@ -627,8 +627,8 @@ export declare const ContactResponseSchema: z.ZodEffects<z.ZodObject<{
             canPlaceOrders?: boolean | undefined;
             canViewInvoices?: boolean | undefined;
         } | undefined;
-        phoneNumber?: string | undefined;
         isPrimary?: boolean | undefined;
+        phoneNumber?: string | undefined;
         webEnabled?: boolean | undefined;
         loginCredentials?: {
             username?: string | undefined;

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

@@ -0,0 +1,336 @@
+import { BaseServiceClient } from '../../core/base-client';
+import type { HTTPClient } from '../../core/client';
+import { ChatGptAskRequestParams, ChatGptAskResponse, ChatGptAskResult, DocumentsListResponse, DocumentsListResult, OllamaGenerateRequestParams, OllamaGenerateResult } from './schemas';
+/**
+ * Gregorovich AI Service Client
+ *
+ * Provides access to AI-powered document management and conversational AI endpoints
+ * including ChatGPT integration, Ollama local models, and document processing capabilities.
+ *
+ * @service gregorovich
+ * @domain ai-and-document-management
+ */
+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
+     * ```
+     */
+    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;
+        };
+        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
+     */
+    readonly chatGptAskData: (params: ChatGptAskRequestParams) => Promise<ChatGptAskResult>;
+    /**
+     * List documents and return documents array data only
+     * @returns Promise<DocumentsListResult[]> Array of document objects
+     */
+    readonly documentsListData: () => Promise<DocumentsListResult[]>;
+    /**
+     * 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
+     */
+    readonly ollamaGenerateData: (params: OllamaGenerateRequestParams) => Promise<OllamaGenerateResult>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/types/services/gregorovich/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/services/gregorovich/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAGL,uBAAuB,EAEvB,kBAAkB,EAClB,gBAAgB,EAEhB,qBAAqB,EACrB,mBAAmB,EAEnB,2BAA2B,EAE3B,oBAAoB,EACrB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;GAQG;AACH,qBAAa,iBAAkB,SAAQ,iBAAiB;gBAC1C,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,MAAM;IAI9C,SAAS,CAAC,qBAAqB,IAAI,MAAM;IAIzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,QAAQ,CAAC,WAAW;;;;;;;;;OAA2D;IAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwDG;IACH,QAAQ,CAAC,UAAU,GAAU,QAAQ,uBAAuB,KAAG,OAAO,CAAC,kBAAkB,CAAC,CAUxF;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiDG;IACH,QAAQ,CAAC,aAAa,QAAa,OAAO,CAAC,qBAAqB,CAAC,CAM/D;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwEG;IACH,QAAQ,CAAC,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAIrB;IAIF;;;OAGG;IACH,QAAQ,CAAC,eAAe,QAAa,OAAO,CAAC,MAAM,CAAC,CAGlD;IAEF;;;;OAIG;IACH,QAAQ,CAAC,cAAc,GAAU,QAAQ,uBAAuB,KAAG,OAAO,CAAC,gBAAgB,CAAC,CAG1F;IAEF;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,QAAa,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAGnE;IAEF;;;;OAIG;IACH,QAAQ,CAAC,kBAAkB,GACzB,QAAQ,2BAA2B,KAClC,OAAO,CAAC,oBAAoB,CAAC,CAG9B;CACH"}

package/dist/types/services/gregorovich/index.d.ts

@@ -0,0 +1,3 @@
+export { GregorovichClient } from './client';
+export type { HealthCheckResponse, ChatGptAskRequestParams, ChatGptAskResponse, ChatGptAskResult, DocumentsListResponse, DocumentsListResult, OllamaGenerateRequestParams, OllamaGenerateResponse, OllamaGenerateResult, } from './schemas';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/services/gregorovich/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/gregorovich/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,YAAY,EAEV,mBAAmB,EAEnB,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAEhB,qBAAqB,EACrB,mBAAmB,EAEnB,2BAA2B,EAC3B,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,WAAW,CAAC"}