@simpleapps-com/augur-api 0.3.3 → 0.4.0

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

@@ -45,569 +45,603 @@ export declare class AgrInfoClient extends BaseServiceClient {
         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
+     * Akasha AI generation endpoints
      */
-    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;
+    readonly akasha: {
+        /**
+         * Generate AI response using Akasha model
+         *
+         * @fullPath api.agrInfo.akasha.generate.create
+         * @service agr-info
+         * @domain ai-content-generation
+         * @dataMethod akasha.generate.createData
+         * @discoverable true
+         * @searchTerms ["akasha", "generate", "ai", "content", "response", "model"]
+         * @relatedEndpoints ["api.agrInfo.joomla.generate.create", "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
+         */
+        generate: {
+            create: (data: {}) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: string;
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * Get generated Akasha AI response data only
+             * @param params Optional generation parameters
+             * @returns Promise<string> Generated AI response
+             */
+            createData: (params?: AkashaGenerateParams) => Promise<string>;
         };
-        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
+     * Joomla AI generation endpoints
      */
-    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;
+    readonly joomla: {
+        /**
+         * Generate AI response using Joomla model
+         *
+         * @fullPath api.agrInfo.joomla.generate.create
+         * @service agr-info
+         * @domain ai-content-generation
+         * @dataMethod joomla.generate.createData
+         * @discoverable true
+         * @searchTerms ["joomla", "generate", "ai", "content", "response", "model"]
+         * @relatedEndpoints ["api.agrInfo.akasha.generate.create", "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
+         */
+        generate: {
+            create: (data: {}) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: string;
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * Get generated Joomla AI response data only
+             * @param params Optional generation parameters
+             * @returns Promise<string> Generated Joomla content
+             */
+            createData: (params?: JoomlaGenerateParams) => Promise<string>;
         };
-        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
+     * Microservices management endpoints
      */
-    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>;
+    readonly microservices: {
+        /**
+         * List available microservices with filtering and pagination
+         *
+         * @fullPath api.agrInfo.microservices.list
+         * @service agr-info
+         * @domain microservice-management
+         * @dataMethod microservices.listData
+         * @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
+         */
+        list: (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 microservices.getData
+         * @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
+         */
+        get: (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 microservices.createData
+         * @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
+         */
+        create: (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 microservices.updateData
+         * @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
+         */
+        update: (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 microservices.deleteData
+         * @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
+         */
+        delete: (id: string | number) => Promise<boolean>;
+        /**
+         * Get microservices list data only
+         * @param params Optional filtering and pagination parameters
+         * @returns Promise<Microservice[]> Array of microservices
+         */
+        listData: (params?: MicroservicesListParams) => Promise<Microservice[]>;
+        /**
+         * Get microservice details data only
+         * @param microservicesUid Unique identifier for the microservice
+         * @returns Promise<Microservice> Microservice details
+         */
+        getData: (microservicesUid: string | number) => Promise<Microservice>;
+        /**
+         * Get created microservice data only
+         * @param data Microservice creation data
+         * @returns Promise<Microservice> Created microservice
+         */
+        createData: (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
+         */
+        updateData: (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
+         */
+        deleteData: (microservicesUid: 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
+     * Rubrics management endpoints
      */
-    readonly rubricsList: (params?: {} | undefined) => Promise<{
-        params: Record<string, unknown> | unknown[];
-        data: import("zod").objectInputType<{
-            rubrics_uid: import("zod").ZodNumber;
+    readonly rubrics: {
+        /**
+         * List available rubrics for evaluation and scoring
+         *
+         * @fullPath api.agrInfo.rubrics.list
+         * @service agr-info
+         * @domain evaluation-management
+         * @dataMethod rubrics.listData
+         * @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
+         */
+        list: (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 rubrics.getData
+         * @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
+         */
+        get: (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 rubrics.createData
+         * @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
+         */
+        create: (data: import("zod").objectInputType<{
             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;
-    }>;
+        }, 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 rubrics.updateData
+         * @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
+         */
+        update: (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 rubrics.deleteData
+         * @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
+         */
+        delete: (id: string | number) => Promise<boolean>;
+        /**
+         * Get rubrics list data only
+         * @param params Optional filtering parameters
+         * @returns Promise<Rubric[]> Array of rubrics
+         */
+        listData: (params?: RubricsListParams) => Promise<Rubric[]>;
+        /**
+         * Get rubric details data only
+         * @param rubricsUid Unique identifier for the rubric
+         * @returns Promise<Rubric> Rubric details
+         */
+        getData: (rubricsUid: string | number) => Promise<Rubric>;
+        /**
+         * Get created rubric data only
+         * @param data Rubric creation data
+         * @returns Promise<Rubric> Created rubric
+         */
+        createData: (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
+         */
+        updateData: (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
+         */
+        deleteData: (rubricsUid: string | number) => Promise<boolean>;
+    };
     /**
-     * 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
+     * Ollama AI model management endpoints
      */
-    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;
+    readonly ollama: {
+        /**
+         * Ollama tags endpoints
+         */
+        tags: {
+            /**
+             * Get list of available Ollama AI model tags and versions
+             *
+             * @fullPath api.agrInfo.ollama.tags.list
+             * @service agr-info
+             * @domain ai-model-management
+             * @dataMethod ollama.tags.listData
+             * @discoverable true
+             * @searchTerms ["ollama", "tags", "models", "ai", "versions", "available"]
+             * @relatedEndpoints ["api.agrInfo.akasha.generate.create", "api.agrInfo.joomla.generate.create"]
+             * @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
+             */
+            list: (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 Ollama tags list data only
+             * @returns Promise<OllamaTag[]> Array of available Ollama model tags
+             */
+            listData: () => Promise<OllamaTag[]>;
         };
-        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