@simpleapps-com/augur-api 0.2.13 → 0.3.1

package/dist/esm/services/agr-info/client.d.ts

@@ -0,0 +1,613 @@
+import { BaseServiceClient } from '../../core/base-client';
+import type { HTTPClient } from '../../core/client';
+import { MicroservicesListParams, MicroserviceCreateParams, MicroserviceUpdateParams, Microservice, RubricsListParams, RubricCreateParams, RubricUpdateParams, Rubric, AkashaGenerateParams, JoomlaGenerateParams, OllamaTag } from './schemas';
+/**
+ * AGR Info Service Client
+ *
+ * Provides access to AGR info service endpoints for AI-powered content generation,
+ * microservice management, rubrics, and Ollama integration.
+ *
+ * @service agr-info
+ * @domain ai-content-generation
+ */
+export declare class AgrInfoClient extends BaseServiceClient {
+    constructor(http: HTTPClient, baseUrl?: string);
+    protected getServiceDescription(): string;
+    /**
+     * Check service health and availability
+     *
+     * @fullPath api.agrInfo.healthCheck.get
+     * @service agr-info
+     * @domain system-health
+     * @dataMethod healthCheckData
+     * @discoverable true
+     * @searchTerms ["health", "status", "availability", "ping", "check"]
+     * @relatedEndpoints ["api.customers.healthCheck.get", "api.commerce.healthCheck.get", "api.items.healthCheck.get"]
+     * @commonPatterns ["Health check", "Service status", "API availability"]
+     * @workflow ["system-monitoring", "health-checks", "service-discovery"]
+     * @prerequisites ["Service is running"]
+     * @nextSteps ["Use other endpoints if healthy"]
+     * @businessRules ["Returns service status and basic info"]
+     * @functionalArea "system-monitoring"
+     * @caching "No caching - real-time status"
+     * @performance "Fast response, minimal processing"
+     *
+     * @returns Promise<HealthCheckResponse> Service health status
+     */
+    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;
+    }>;
+    /**
+     * Generate AI response using Akasha model
+     *
+     * @fullPath api.agrInfo.akasha.generate
+     * @service agr-info
+     * @domain ai-content-generation
+     * @dataMethod akashaGenerateData
+     * @discoverable true
+     * @searchTerms ["akasha", "generate", "ai", "content", "response", "model"]
+     * @relatedEndpoints ["api.agrInfo.joomla.generate", "api.agrInfo.ollama.tags.list"]
+     * @commonPatterns ["Generate AI content", "AI response generation", "Content creation"]
+     * @workflow ["content-generation", "ai-processing", "response-creation"]
+     * @prerequisites ["Valid authentication", "AI model availability"]
+     * @nextSteps ["Process generated content", "Store or display results"]
+     * @businessRules ["Requires public bearer token", "May have rate limits"]
+     * @functionalArea "ai-content-generation"
+     * @caching "No caching - dynamic AI responses"
+     * @performance "Variable response time based on AI processing"
+     *
+     * @param params Optional generation parameters
+     * @returns Promise<AkashaGenerateResponse> Generated AI response
+     */
+    readonly akashaGenerate: (data: {}) => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: string;
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+    /**
+     * Generate AI response using Joomla model
+     *
+     * @fullPath api.agrInfo.joomla.generate
+     * @service agr-info
+     * @domain ai-content-generation
+     * @dataMethod joomlaGenerateData
+     * @discoverable true
+     * @searchTerms ["joomla", "generate", "ai", "content", "response", "model"]
+     * @relatedEndpoints ["api.agrInfo.akasha.generate", "api.agrInfo.ollama.tags.list", "api.joomla.content.list"]
+     * @commonPatterns ["Generate Joomla content", "AI content for CMS", "Joomla AI integration"]
+     * @workflow ["content-generation", "cms-integration", "ai-processing"]
+     * @prerequisites ["Valid authentication", "Joomla model availability"]
+     * @nextSteps ["Integrate with Joomla CMS", "Publish generated content"]
+     * @businessRules ["Requires public bearer token", "Content should be Joomla-compatible"]
+     * @functionalArea "ai-content-generation"
+     * @caching "No caching - dynamic AI responses"
+     * @performance "Variable response time based on AI processing"
+     *
+     * @param params Optional generation parameters
+     * @returns Promise<JoomlaGenerateResponse> Generated Joomla-compatible content
+     */
+    readonly joomlaGenerate: (data: {}) => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: string;
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+    /**
+     * List available microservices with filtering and pagination
+     *
+     * @fullPath api.agrInfo.microservices.list
+     * @service agr-info
+     * @domain microservice-management
+     * @dataMethod microservicesListData
+     * @discoverable true
+     * @searchTerms ["microservices", "services", "list", "status", "infrastructure"]
+     * @relatedEndpoints ["api.agrInfo.microservices.get", "api.agrInfo.microservices.create"]
+     * @commonPatterns ["List all microservices", "Filter by status", "Service discovery"]
+     * @workflow ["service-discovery", "infrastructure-monitoring", "microservice-management"]
+     * @prerequisites ["Valid authentication", "Public access permissions"]
+     * @nextSteps ["Get specific microservice details", "Manage individual services"]
+     * @businessRules ["Supports pagination", "Can filter by status code", "Returns service metadata"]
+     * @functionalArea "microservice-management"
+     * @caching "Cache for 2 minutes, invalidate on service changes"
+     * @performance "Use pagination for large service lists"
+     *
+     * @param params Optional filtering and pagination parameters
+     * @returns Promise<MicroservicesListResponse> List of microservices
+     */
+    readonly microservicesList: (params?: {
+        limit?: number | undefined;
+        offset?: number | undefined;
+        statusCd?: number | undefined;
+    } | undefined) => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: import("zod").objectInputType<{
+            microservices_uid: import("zod").ZodNumber;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+            status_cd: import("zod").ZodOptional<import("zod").ZodNumber>;
+            created_at: import("zod").ZodOptional<import("zod").ZodString>;
+            updated_at: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">[];
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+    /**
+     * Get specific microservice details by UID
+     *
+     * @fullPath api.agrInfo.microservices.get
+     * @service agr-info
+     * @domain microservice-management
+     * @dataMethod microservicesGetData
+     * @discoverable true
+     * @searchTerms ["microservice", "details", "get", "service", "info"]
+     * @relatedEndpoints ["api.agrInfo.microservices.list", "api.agrInfo.microservices.update", "api.agrInfo.microservices.delete"]
+     * @commonPatterns ["Get service details", "Service information", "Microservice lookup"]
+     * @workflow ["service-inspection", "microservice-management", "configuration-review"]
+     * @prerequisites ["Valid authentication", "Valid microservice UID"]
+     * @nextSteps ["Update service configuration", "Monitor service status"]
+     * @businessRules ["Requires valid microservices_uid", "Returns complete service metadata"]
+     * @functionalArea "microservice-management"
+     * @caching "Cache for 5 minutes, real-time for critical services"
+     * @performance "Fast lookup by UID"
+     *
+     * @param microservicesUid Unique identifier for the microservice
+     * @returns Promise<MicroserviceResponse> Microservice details
+     */
+    readonly microservicesGet: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: {
+            microservices_uid: number;
+            name?: string | undefined;
+            status_cd?: number | undefined;
+            created_at?: string | undefined;
+            updated_at?: string | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+    /**
+     * Create a new microservice
+     *
+     * @fullPath api.agrInfo.microservices.create
+     * @service agr-info
+     * @domain microservice-management
+     * @dataMethod microservicesCreateData
+     * @discoverable true
+     * @searchTerms ["microservice", "create", "add", "new", "service", "register"]
+     * @relatedEndpoints ["api.agrInfo.microservices.list", "api.agrInfo.microservices.get", "api.agrInfo.microservices.update"]
+     * @commonPatterns ["Register new service", "Add microservice", "Service registration"]
+     * @workflow ["service-deployment", "microservice-registration", "infrastructure-setup"]
+     * @prerequisites ["Valid authentication", "Service deployment ready"]
+     * @nextSteps ["Configure service settings", "Monitor new service health"]
+     * @businessRules ["Validates service configuration", "Assigns unique UID", "Sets initial status"]
+     * @functionalArea "microservice-management"
+     * @caching "No caching - immediate registration"
+     * @performance "Fast registration with validation"
+     *
+     * @param data Microservice creation data
+     * @returns Promise<MicroserviceResponse> Created microservice details
+     */
+    readonly microservicesCreate: (data: import("zod").objectInputType<{
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        status_cd: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod").ZodTypeAny, "passthrough">) => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: {
+            microservices_uid: number;
+            name?: string | undefined;
+            status_cd?: number | undefined;
+            created_at?: string | undefined;
+            updated_at?: string | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+    /**
+     * Update existing microservice configuration
+     *
+     * @fullPath api.agrInfo.microservices.update
+     * @service agr-info
+     * @domain microservice-management
+     * @dataMethod microservicesUpdateData
+     * @discoverable true
+     * @searchTerms ["microservice", "update", "modify", "edit", "configure"]
+     * @relatedEndpoints ["api.agrInfo.microservices.get", "api.agrInfo.microservices.list", "api.agrInfo.microservices.delete"]
+     * @commonPatterns ["Update service config", "Modify microservice", "Change service status"]
+     * @workflow ["service-configuration", "microservice-management", "status-updates"]
+     * @prerequisites ["Valid authentication", "Existing microservice", "Valid microservices_uid"]
+     * @nextSteps ["Verify configuration changes", "Monitor service after update"]
+     * @businessRules ["Validates updated configuration", "Maintains service integrity", "Updates timestamps"]
+     * @functionalArea "microservice-management"
+     * @caching "Invalidate cache on update"
+     * @performance "Fast updates with validation"
+     *
+     * @param microservicesUid Unique identifier for the microservice
+     * @param data Updated microservice data
+     * @returns Promise<MicroserviceResponse> Updated microservice details
+     */
+    readonly microservicesUpdate: (id: string | number, data: import("zod").objectInputType<{
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        status_cd: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod").ZodTypeAny, "passthrough">) => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: {
+            microservices_uid: number;
+            name?: string | undefined;
+            status_cd?: number | undefined;
+            created_at?: string | undefined;
+            updated_at?: string | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+    /**
+     * Delete a microservice
+     *
+     * @fullPath api.agrInfo.microservices.delete
+     * @service agr-info
+     * @domain microservice-management
+     * @dataMethod microservicesDeleteData
+     * @discoverable true
+     * @searchTerms ["microservice", "delete", "remove", "unregister", "decommission"]
+     * @relatedEndpoints ["api.agrInfo.microservices.list", "api.agrInfo.microservices.get"]
+     * @commonPatterns ["Remove service", "Decommission microservice", "Unregister service"]
+     * @workflow ["service-decommission", "microservice-cleanup", "infrastructure-management"]
+     * @prerequisites ["Valid authentication", "Existing microservice", "Service shutdown confirmation"]
+     * @nextSteps ["Verify service removal", "Update infrastructure documentation"]
+     * @businessRules ["Confirms service is not critical", "Cleans up dependencies", "Logs deletion"]
+     * @functionalArea "microservice-management"
+     * @caching "Invalidate all related cache on delete"
+     * @performance "Fast deletion with dependency checks"
+     *
+     * @param microservicesUid Unique identifier for the microservice
+     * @returns Promise<boolean> Success indicator
+     */
+    readonly microservicesDelete: (id: string | number) => Promise<boolean>;
+    /**
+     * List available rubrics for evaluation and scoring
+     *
+     * @fullPath api.agrInfo.rubrics.list
+     * @service agr-info
+     * @domain evaluation-management
+     * @dataMethod rubricsListData
+     * @discoverable true
+     * @searchTerms ["rubrics", "evaluation", "scoring", "assessment", "criteria"]
+     * @relatedEndpoints ["api.agrInfo.rubrics.get", "api.agrInfo.rubrics.create"]
+     * @commonPatterns ["List evaluation rubrics", "Get assessment criteria", "Scoring frameworks"]
+     * @workflow ["evaluation-setup", "assessment-preparation", "scoring-criteria"]
+     * @prerequisites ["Valid authentication", "Evaluation system access"]
+     * @nextSteps ["Select rubric for evaluation", "Create new assessment"]
+     * @businessRules ["Returns available evaluation frameworks", "Includes rubric metadata"]
+     * @functionalArea "evaluation-management"
+     * @caching "Cache for 10 minutes, stable evaluation criteria"
+     * @performance "Fast retrieval of evaluation frameworks"
+     *
+     * @param params Optional filtering parameters
+     * @returns Promise<RubricsListResponse> List of available rubrics
+     */
+    readonly rubricsList: (params?: {} | undefined) => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: import("zod").objectInputType<{
+            rubrics_uid: import("zod").ZodNumber;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            created_at: import("zod").ZodOptional<import("zod").ZodString>;
+            updated_at: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">[];
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+    /**
+     * Get specific rubric details and criteria
+     *
+     * @fullPath api.agrInfo.rubrics.get
+     * @service agr-info
+     * @domain evaluation-management
+     * @dataMethod rubricsGetData
+     * @discoverable true
+     * @searchTerms ["rubric", "details", "criteria", "evaluation", "scoring"]
+     * @relatedEndpoints ["api.agrInfo.rubrics.list", "api.agrInfo.rubrics.update", "api.agrInfo.rubrics.delete"]
+     * @commonPatterns ["Get rubric details", "View evaluation criteria", "Rubric information"]
+     * @workflow ["evaluation-review", "assessment-setup", "scoring-preparation"]
+     * @prerequisites ["Valid authentication", "Valid rubric UID"]
+     * @nextSteps ["Use rubric for evaluation", "Modify rubric criteria"]
+     * @businessRules ["Returns complete rubric structure", "Includes all evaluation criteria"]
+     * @functionalArea "evaluation-management"
+     * @caching "Cache for 15 minutes, evaluation criteria are stable"
+     * @performance "Fast lookup by rubric UID"
+     *
+     * @param rubricsUid Unique identifier for the rubric
+     * @returns Promise<RubricResponse> Rubric details and criteria
+     */
+    readonly rubricsGet: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: {
+            rubrics_uid: number;
+            description?: string | undefined;
+            name?: string | undefined;
+            created_at?: string | undefined;
+            updated_at?: string | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+    /**
+     * Create a new evaluation rubric
+     *
+     * @fullPath api.agrInfo.rubrics.create
+     * @service agr-info
+     * @domain evaluation-management
+     * @dataMethod rubricsCreateData
+     * @discoverable true
+     * @searchTerms ["rubric", "create", "new", "evaluation", "assessment", "criteria"]
+     * @relatedEndpoints ["api.agrInfo.rubrics.list", "api.agrInfo.rubrics.get", "api.agrInfo.rubrics.update"]
+     * @commonPatterns ["Create evaluation rubric", "New assessment framework", "Define scoring criteria"]
+     * @workflow ["rubric-development", "evaluation-setup", "assessment-creation"]
+     * @prerequisites ["Valid authentication", "Evaluation design requirements"]
+     * @nextSteps ["Define detailed criteria", "Test rubric with evaluations"]
+     * @businessRules ["Validates rubric structure", "Assigns unique UID", "Sets creation metadata"]
+     * @functionalArea "evaluation-management"
+     * @caching "No caching - immediate creation"
+     * @performance "Fast creation with validation"
+     *
+     * @param data Rubric creation data
+     * @returns Promise<RubricResponse> Created rubric details
+     */
+    readonly rubricsCreate: (data: import("zod").objectInputType<{
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">) => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: {
+            rubrics_uid: number;
+            description?: string | undefined;
+            name?: string | undefined;
+            created_at?: string | undefined;
+            updated_at?: string | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+    /**
+     * Update existing rubric criteria and configuration
+     *
+     * @fullPath api.agrInfo.rubrics.update
+     * @service agr-info
+     * @domain evaluation-management
+     * @dataMethod rubricsUpdateData
+     * @discoverable true
+     * @searchTerms ["rubric", "update", "modify", "edit", "criteria", "evaluation"]
+     * @relatedEndpoints ["api.agrInfo.rubrics.get", "api.agrInfo.rubrics.list", "api.agrInfo.rubrics.delete"]
+     * @commonPatterns ["Update rubric criteria", "Modify evaluation framework", "Edit scoring system"]
+     * @workflow ["rubric-maintenance", "evaluation-improvement", "assessment-refinement"]
+     * @prerequisites ["Valid authentication", "Existing rubric", "Valid rubrics_uid"]
+     * @nextSteps ["Validate updated criteria", "Re-test evaluation accuracy"]
+     * @businessRules ["Preserves evaluation integrity", "Updates modification timestamps", "Validates criteria"]
+     * @functionalArea "evaluation-management"
+     * @caching "Invalidate cache on update"
+     * @performance "Fast updates with validation"
+     *
+     * @param rubricsUid Unique identifier for the rubric
+     * @param data Updated rubric data
+     * @returns Promise<RubricResponse> Updated rubric details
+     */
+    readonly rubricsUpdate: (id: string | number, data: import("zod").objectInputType<{
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">) => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: {
+            rubrics_uid: number;
+            description?: string | undefined;
+            name?: string | undefined;
+            created_at?: string | undefined;
+            updated_at?: string | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+    /**
+     * Delete an evaluation rubric
+     *
+     * @fullPath api.agrInfo.rubrics.delete
+     * @service agr-info
+     * @domain evaluation-management
+     * @dataMethod rubricsDeleteData
+     * @discoverable true
+     * @searchTerms ["rubric", "delete", "remove", "evaluation", "cleanup"]
+     * @relatedEndpoints ["api.agrInfo.rubrics.list", "api.agrInfo.rubrics.get"]
+     * @commonPatterns ["Remove rubric", "Delete evaluation framework", "Cleanup assessments"]
+     * @workflow ["rubric-cleanup", "evaluation-maintenance", "assessment-removal"]
+     * @prerequisites ["Valid authentication", "Existing rubric", "No active evaluations using rubric"]
+     * @nextSteps ["Verify rubric removal", "Update evaluation documentation"]
+     * @businessRules ["Checks for active usage", "Prevents deletion of in-use rubrics", "Logs deletion"]
+     * @functionalArea "evaluation-management"
+     * @caching "Invalidate all related cache on delete"
+     * @performance "Fast deletion with dependency validation"
+     *
+     * @param rubricsUid Unique identifier for the rubric
+     * @returns Promise<boolean> Success indicator
+     */
+    readonly rubricsDelete: (id: string | number) => Promise<boolean>;
+    /**
+     * Get list of available Ollama AI model tags and versions
+     *
+     * @fullPath api.agrInfo.ollama.tags.list
+     * @service agr-info
+     * @domain ai-model-management
+     * @dataMethod ollamaTagsListData
+     * @discoverable true
+     * @searchTerms ["ollama", "tags", "models", "ai", "versions", "available"]
+     * @relatedEndpoints ["api.agrInfo.akasha.generate", "api.agrInfo.joomla.generate"]
+     * @commonPatterns ["List AI models", "Available Ollama tags", "Model discovery"]
+     * @workflow ["model-discovery", "ai-setup", "model-selection"]
+     * @prerequisites ["Valid authentication", "Ollama service availability"]
+     * @nextSteps ["Select model for AI generation", "Configure AI workflows"]
+     * @businessRules ["Returns available model versions", "Includes model metadata", "Shows compatibility info"]
+     * @functionalArea "ai-model-management"
+     * @caching "Cache for 30 minutes, model availability changes slowly"
+     * @performance "Fast model listing, cached for efficiency"
+     *
+     * @returns Promise<OllamaTagsResponse> List of available Ollama model tags
+     */
+    readonly ollamaTagsList: (params?: {} | undefined) => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: import("zod").objectInputType<{
+            name: import("zod").ZodString;
+            model: import("zod").ZodOptional<import("zod").ZodString>;
+            size: import("zod").ZodOptional<import("zod").ZodNumber>;
+            digest: import("zod").ZodOptional<import("zod").ZodString>;
+            modified_at: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">[];
+        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>;
+    /**
+     * Get generated Akasha AI response data only
+     * @param params Optional generation parameters
+     * @returns Promise<string> Generated AI response
+     */
+    readonly akashaGenerateData: (params?: AkashaGenerateParams) => Promise<string>;
+    /**
+     * Get generated Joomla AI response data only
+     * @param params Optional generation parameters
+     * @returns Promise<string> Generated Joomla content
+     */
+    readonly joomlaGenerateData: (params?: JoomlaGenerateParams) => Promise<string>;
+    /**
+     * Get microservices list data only
+     * @param params Optional filtering and pagination parameters
+     * @returns Promise<Microservice[]> Array of microservices
+     */
+    readonly microservicesListData: (params?: MicroservicesListParams) => Promise<Microservice[]>;
+    /**
+     * Get microservice details data only
+     * @param microservicesUid Unique identifier for the microservice
+     * @returns Promise<Microservice> Microservice details
+     */
+    readonly microservicesGetData: (microservicesUid: string | number) => Promise<Microservice>;
+    /**
+     * Get created microservice data only
+     * @param data Microservice creation data
+     * @returns Promise<Microservice> Created microservice
+     */
+    readonly microservicesCreateData: (data: MicroserviceCreateParams) => Promise<Microservice>;
+    /**
+     * Get updated microservice data only
+     * @param microservicesUid Unique identifier for the microservice
+     * @param data Updated microservice data
+     * @returns Promise<Microservice> Updated microservice
+     */
+    readonly microservicesUpdateData: (microservicesUid: string | number, data: MicroserviceUpdateParams) => Promise<Microservice>;
+    /**
+     * Delete microservice and return success status
+     * @param microservicesUid Unique identifier for the microservice
+     * @returns Promise<boolean> Success indicator
+     */
+    readonly microservicesDeleteData: (microservicesUid: string | number) => Promise<boolean>;
+    /**
+     * Get rubrics list data only
+     * @param params Optional filtering parameters
+     * @returns Promise<Rubric[]> Array of rubrics
+     */
+    readonly rubricsListData: (params?: RubricsListParams) => Promise<Rubric[]>;
+    /**
+     * Get rubric details data only
+     * @param rubricsUid Unique identifier for the rubric
+     * @returns Promise<Rubric> Rubric details
+     */
+    readonly rubricsGetData: (rubricsUid: string | number) => Promise<Rubric>;
+    /**
+     * Get created rubric data only
+     * @param data Rubric creation data
+     * @returns Promise<Rubric> Created rubric
+     */
+    readonly rubricsCreateData: (data: RubricCreateParams) => Promise<Rubric>;
+    /**
+     * Get updated rubric data only
+     * @param rubricsUid Unique identifier for the rubric
+     * @param data Updated rubric data
+     * @returns Promise<Rubric> Updated rubric
+     */
+    readonly rubricsUpdateData: (rubricsUid: string | number, data: RubricUpdateParams) => Promise<Rubric>;
+    /**
+     * Delete rubric and return success status
+     * @param rubricsUid Unique identifier for the rubric
+     * @returns Promise<boolean> Success indicator
+     */
+    readonly rubricsDeleteData: (rubricsUid: string | number) => Promise<boolean>;
+    /**
+     * Get Ollama tags list data only
+     * @returns Promise<OllamaTag[]> Array of available Ollama model tags
+     */
+    readonly ollamaTagsListData: () => Promise<OllamaTag[]>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/esm/services/agr-info/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/services/agr-info/client.ts"],"names":[],"mappings":"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"}