@simpleapps-com/augur-api 0.4.1 → 0.4.3

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

@@ -1,14 +1,9 @@
 import { BaseServiceClient } from '../../core/base-client';
 import type { HTTPClient } from '../../core/client';
-import { GenericResponse, VerifyPasswordRequest, VerifyPasswordResponse, CreateUserRequestSchema, UpdateUserRequestSchema } from './schemas';
-import type { z } from 'zod';
-import { BaseGetParamsSchema } from '../../core/schemas';
-type CreateUserRequest = z.infer<typeof CreateUserRequestSchema>;
-type UpdateUserRequest = z.infer<typeof UpdateUserRequestSchema>;
-type BaseGetParams = z.infer<typeof BaseGetParamsSchema>;
+import { type ContentParams, type ContentResponse, type ContentIdParams, type ContentIdResponse, type ContentIdDocParams, type ContentIdDocResponse, type HealthCheckResponse, type MenuIdDocResponse, type TagsParams, type TagsResponse, type UsersIdGroupsGroupIdResponse, type UsersIdGroupsParams, type UsersIdGroupsResponse, type UsersIdGroupsCreateRequest, type UsersIdGroupsCreateResponse, type UserGroupsParams, type UserGroupsResponse, type UsersIdResponse, type UsersIdUpdateRequest, type UsersIdUpdateResponse, type UsersIdDeleteResponse, type UsersIdDocResponse, type UsersIdTrinityParams, type UsersIdTrinityResponse, type UsersParams, type UsersResponse, type UsersCreateRequest, type UsersCreateResponse, type UsersVerifyPasswordRequest, type UsersVerifyPasswordResponse } from './schemas';
 /**
- * Joomla API Client
- * @description Client for interacting with Joomla microservice API endpoints
+ * Joomla API Client - OpenAPI Compliant
+ * @description Fully compliant client following OpenAPI Path Mirroring Pattern
  * @example
  * ```typescript
  * import { HTTPClient } from '@augur/api-client/core';
@@ -17,831 +12,793 @@ type BaseGetParams = z.infer<typeof BaseGetParamsSchema>;
  * const http = new HTTPClient('joomla', { siteId: 'your-site-id', bearerToken: 'your-token' });
  * const joomla = new JoomlaClient(http);
  *
- * // List content
- * const content = await joomla.content.list({ limit: 10 });
+ * // OpenAPI Path Mirroring: /content GET -> client.content.get()
+ * const content = await joomla.content.get({ limit: 10 });
  *
- * // Verify user password
- * const auth = await joomla.users.verifyPassword({ username: 'user', password: 'pass' });
+ * // OpenAPI Path Mirroring: /users/verify-password POST -> client.users.verifyPassword.create()
+ * const auth = await joomla.users.verifyPassword.create({ username: 'user', password: 'pass' });
  * ```
  */
 export declare class JoomlaClient extends BaseServiceClient {
-    /**
-     * Create a new JoomlaClient instance
-     * @param http Configured HTTPClient instance
-     * @param baseUrl Base URL for the Joomla API (default: https://joomla.augur-api.com)
-     */
     constructor(http: HTTPClient, baseUrl?: string);
     /**
-     * Content endpoints
-     * @description Methods for content management including articles, documents, and metadata
+     * Content endpoints - /content
      */
     content: {
         /**
-         * Retrieve a paginated list of content items
-         * @description Returns articles, documents, and content with filtering, pagination, and edge caching capabilities
-         * @fullPath api.joomla.content.list
+         * List content items - /content GET
+         * @fullPath api.joomla.content.get
          * @service joomla
          * @domain content-management
-         * @dataMethod listData() - returns only the content array without metadata
-         * @pagination Uses count, total, totalResults for pagination metadata. Supports limit/offset parameters.
-         * @caching Supports edgeCache parameter (1-8 hours) for improved performance on content that changes infrequently
+         * @dataMethod getData() - returns only the content array without metadata
          * @discoverable true
-         * @searchTerms ["content", "articles", "list content", "cms content", "documents", "blog posts"]
-         * @relatedEndpoints ["api.joomla.content.get", "api.joomla.content.getDoc", "api.joomla.tags.list"]
-         * @commonPatterns ["list articles", "get content", "blog content", "cms articles", "filter content"]
-         * @param params Optional filtering, pagination, and caching parameters
-         * @param params.categoryIdList Comma-separated list of category IDs to filter content (e.g., '1,2,3')
-         * @param params.q Search query for filtering content by title/text
-         * @param params.limit Maximum number of content items to return (default: 20, max: 100)
-         * @param params.offset Number of items to skip for pagination (default: 0)
-         * @param params.edgeCache Cache duration in hours (1, 2, 3, 4, 5, 8) - recommended for content
-         * @returns BaseResponse<ContentItem[]> with pagination metadata and content array
-         * @throws ValidationError When parameters are invalid or response is malformed
-         * @example
-         * ```typescript
-         * // Get all content with full response metadata
-         * const response = await api.joomla.content.list();
-         * console.log(`Found ${response.total} articles, showing ${response.data.length}`);
-         *
-         * // Filter content by categories with search
-         * const filtered = await api.joomla.content.list({
-         *   categoryIdList: '1,2,3',
-         *   q: 'product review',
-         *   limit: 10
-         * });
-         *
-         * // Get just content data without metadata
-         * const articles = await api.joomla.content.listData({
-         *   categoryIdList: '5',
-         *   limit: 20
-         * });
-         * articles.forEach(article => console.log(article.title, article.alias));
-         *
-         * // Use aggressive caching for content (recommended)
-         * const cachedContent = await api.joomla.content.list({
-         *   edgeCache: 4,  // Cache for 4 hours - content changes infrequently
-         *   categoryIdList: '1,2,3'
-         * });
-         * ```
+         * @searchTerms ["content", "articles", "list content", "cms content"]
+         * @relatedEndpoints ["api.joomla.content.get", "api.joomla.content.doc.get"]
+         * @commonPatterns ["list articles", "get content", "cms articles"]
          */
-        list: (params?: {
-            edgeCache?: 3 | 2 | 4 | 1 | "1" | 5 | 8 | "2" | "3" | "4" | "5" | "8" | undefined;
-            limit?: number | undefined;
-            offset?: number | undefined;
-        } | undefined) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: unknown[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
+        get: (params?: ContentParams) => Promise<ContentResponse>;
         /**
-         * Get content details by ID or alias
-         * @description Returns a single content item by its ID or alias with optional edge caching and full content metadata
-         * @fullPath api.joomla.content.get
+         * Get content data only - /content GET (data method)
+         * @fullPath api.joomla.content.getData
          * @service joomla
          * @domain content-management
-         * @dataMethod getData(contentId, params) - returns only the content object without metadata
-         * @caching Supports edgeCache parameter (1-8 hours) for improved performance
-         * @aliasLookup Supports alias-based lookup by using contentId=0 with params.alias
+         * @dataMethod getData() - returns only the content array without metadata
          * @discoverable true
-         * @searchTerms ["get content", "content details", "article details", "content by id", "single content"]
-         * @relatedEndpoints ["api.joomla.content.list", "api.joomla.content.getDoc", "api.joomla.tags.list"]
-         * @commonPatterns ["get content by id", "fetch article", "content details lookup", "get by alias"]
-         * @param contentId Content ID (number) or use 0 for alias lookup
-         * @param params Optional parameters for alias lookup and caching
-         * @param params.alias Content alias for lookup when contentId is 0
-         * @param params.catid Category ID for alias lookup specificity
-         * @param params.edgeCache Cache duration in hours (1, 2, 3, 4, 5, 8) for improved performance
-         * @returns BaseResponse<ContentItem> with complete content details and metadata
-         * @throws ValidationError When parameters are invalid or response is malformed
-         * @example
-         * ```typescript
-         * // Get content by ID with full response metadata
-         * const response = await api.joomla.content.get(123);
-         * console.log('Article:', response.data.title, 'Status:', response.status);
-         *
-         * // Get content by alias
-         * const byAlias = await api.joomla.content.get(0, {
-         *   alias: 'my-article',
-         *   catid: 45
-         * });
-         *
-         * // Get just content data without metadata
-         * const article = await api.joomla.content.getData(123);
-         * console.log(article.title, article.introtext, article.fulltext);
-         *
-         * // Use edge caching for frequently accessed content
-         * const cachedContent = await api.joomla.content.get(123, { edgeCache: 8 });
-         * ```
-         */
-        get: (contentId: number | string, params?: BaseGetParams) => Promise<GenericResponse>;
-        /**
-         * Get content documentation
-         * @description Returns enhanced content document with custom fields, images, and metadata
-         * @param contentId Content ID (number) or alias lookup (use 0 with query params)
-         * @returns Enhanced content document with additional metadata
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * const doc = await client.content.getDoc(123);
-         * console.log(doc.id, doc.title, doc.content, doc.metadata);
-         * ```
+         * @searchTerms ["content data", "articles data", "get content data", "cms content data"]
+         * @relatedEndpoints ["api.joomla.content.get"]
+         * @commonPatterns ["get content data only", "extract article data"]
          */
-        getDoc: (id: string | number, params?: unknown) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-            data?: unknown;
-        }>;
+        getData: (params?: ContentParams) => Promise<{
+            id: number;
+            title: string;
+            alias: string;
+            introtext: string;
+            catid: number;
+            created: string;
+            created_by: number;
+            modified: string;
+            modified_by: number;
+            publish_up: string;
+            publish_down: string | null;
+            state: number;
+            access: number;
+            language: string;
+            hits: number;
+            featured: number;
+            ordering: number;
+            fulltext?: string | undefined;
+            metakey?: string | undefined;
+            metadesc?: string | undefined;
+        }[]>;
         /**
-         * Retrieve a paginated list of content items (data only)
-         * @description Returns only the data array from content items response
-         * @param params Optional filtering, pagination, and caching parameters
-         * @returns Array of content items (data only)
-         * @throws ValidationError When parameters are invalid or response is malformed
+         * Get content by ID - /content/{id} GET
+         * @fullPath api.joomla.content.getById
+         * @service joomla
+         * @domain content-management
+         * @dataMethod getByIdData() - returns only the content object without metadata
+         * @discoverable true
+         * @searchTerms ["content by id", "single article", "get article by id"]
+         * @relatedEndpoints ["api.joomla.content.get", "api.joomla.content.doc.get"]
+         * @commonPatterns ["get article details", "fetch content item"]
          */
-        listData: (params?: BaseGetParams) => Promise<unknown[]>;
+        getById: (contentId: number | string, params?: ContentIdParams) => Promise<ContentIdResponse>;
         /**
-         * Get content details by ID (data only)
-         * @description Returns only the data from content item details response
-         * @param contentId Content ID (number) or alias lookup (use 0 with params.alias)
-         * @param params Optional parameters for alias lookup and caching
-         * @returns Content item details (data only)
-         * @throws ValidationError When parameters are invalid or response is malformed
+         * Get content by ID data only - /content/{id} GET (data method)
+         * @fullPath api.joomla.content.getByIdData
+         * @service joomla
+         * @domain content-management
+         * @dataMethod getByIdData() - returns only the content object without metadata
+         * @discoverable true
+         * @searchTerms ["content data by id", "article data", "single content data"]
+         * @relatedEndpoints ["api.joomla.content.getById"]
+         * @commonPatterns ["extract article data", "get content data only"]
          */
-        getData: (contentId: number | string, params?: BaseGetParams) => Promise<unknown>;
+        getByIdData: (contentId: number | string, params?: ContentIdParams) => Promise<{
+            id: number;
+            title: string;
+            alias: string;
+            introtext: string;
+            fulltext: string;
+            catid: number;
+            created: string;
+            created_by: number;
+            modified: string;
+            modified_by: number;
+            publish_up: string;
+            publish_down: string | null;
+            state: number;
+            access: number;
+            language: string;
+            metakey: string;
+            metadesc: string;
+            hits: number;
+            featured: number;
+            ordering: number;
+            category_title?: string | undefined;
+            created_by_alias?: string | undefined;
+            images?: string | undefined;
+            urls?: string | undefined;
+            attribs?: string | undefined;
+            metadata?: string | undefined;
+        }>;
         /**
-         * Get content documentation (data only)
-         * @description Returns only the data from enhanced content document response
-         * @param contentId Content ID (number) or alias lookup (use 0 with query params)
-         * @returns Enhanced content document (data only)
-         * @throws ValidationError When response is malformed
+         * Content document endpoints - /content/{id}/doc
          */
-        getDocData: (contentId: number | string) => Promise<unknown>;
+        doc: {
+            /**
+             * Get content document - /content/{id}/doc GET
+             * @fullPath api.joomla.content.doc.get
+             * @service joomla
+             * @domain content-management
+             * @dataMethod getData() - returns only the document data without metadata
+             * @discoverable true
+             * @searchTerms ["content document", "article document", "content doc", "full content"]
+             * @relatedEndpoints ["api.joomla.content.getById"]
+             * @commonPatterns ["get full content document", "fetch article with metadata"]
+             */
+            get: (contentId: number | string, params?: ContentIdDocParams) => Promise<ContentIdDocResponse>;
+            /**
+             * Get content document data only - /content/{id}/doc GET (data method)
+             * @fullPath api.joomla.content.doc.getData
+             * @service joomla
+             * @domain content-management
+             * @dataMethod getData() - returns only the document data without metadata
+             * @discoverable true
+             * @searchTerms ["content document data", "article doc data", "full content data"]
+             * @relatedEndpoints ["api.joomla.content.doc.get"]
+             * @commonPatterns ["extract document data", "get full content data only"]
+             */
+            getData: (contentId: number | string, params?: ContentIdDocParams) => Promise<{
+                id: number;
+                title: string;
+                alias: string;
+                introtext: string;
+                fulltext: string;
+                catid: number;
+                created: string;
+                created_by: number;
+                modified: string;
+                modified_by: number;
+                publish_up: string;
+                publish_down: string | null;
+                state: number;
+                access: number;
+                language: string;
+                metakey: string;
+                metadesc: string;
+                hits: number;
+                featured: number;
+                ordering: number;
+                category_title: string;
+                category_alias: string;
+                created_by_alias?: string | undefined;
+                images?: Record<string, unknown> | undefined;
+                urls?: Record<string, unknown> | undefined;
+                author_name?: string | undefined;
+                custom_fields?: Record<string, unknown> | undefined;
+                tags?: {
+                    id: number;
+                    title: string;
+                    alias: string;
+                }[] | undefined;
+            }>;
+        };
     };
     /**
-     * User endpoints
-     * @description Methods for user management including authentication, CRUD operations, and group management
+     * Health check endpoint - /health-check
      */
-    users: {
+    healthCheck: {
         /**
-         * Retrieve a paginated list of users
-         * @description Returns all users with optional filtering, pagination, and edge caching for user management operations
-         * @fullPath api.joomla.users.list
+         * Service health check
+         * @fullPath api.joomla.healthCheck.get
          * @service joomla
-         * @domain user-management
-         * @dataMethod listData() - returns only the user array without metadata
-         * @pagination Uses count, total, totalResults for pagination metadata. Supports limit/offset parameters.
-         * @caching Supports edgeCache parameter (1-8 hours) for improved performance
+         * @domain system
+         * @dataMethod getData() - returns only the health data without metadata
          * @discoverable true
-         * @searchTerms ["users", "list users", "get users", "user management", "accounts", "profiles"]
-         * @relatedEndpoints ["api.joomla.userGroups.list", "api.customers.customer.list", "api.joomla.users.get"]
-         * @commonPatterns ["list all users", "search users", "paginate users", "filter users"]
-         * @param params Optional filtering, pagination, and caching parameters
-         * @param params.q Search query for filtering users by username/email (optional)
-         * @param params.limit Maximum number of users to return (default: 20, max: 100)
-         * @param params.offset Number of users to skip for pagination (default: 0)
-         * @param params.edgeCache Cache duration in hours (1, 2, 3, 4, 5, 8) for improved performance
-         * @returns BaseResponse<User[]> with pagination metadata and user array
-         * @throws ValidationError When parameters are invalid or response is malformed
-         * @example
-         * ```typescript
-         * // Get all users without search filter
-         * const response = await api.joomla.users.list();
-         * console.log(`Found ${response.total} users, showing ${response.data.length}`);
-         * console.log('Pagination:', { count: response.count, total: response.total });
-         *
-         * // Search users with specific query and pagination
-         * const searchResults = await api.joomla.users.list({
-         *   q: 'simple',
-         *   limit: 10,
-         *   offset: 0
-         * });
-         *
-         * // Get just user data without metadata (using data method)
-         * const users = await api.joomla.users.listData({ limit: 20 });
-         * users.forEach(user => console.log(user.username, user.email));
-         *
-         * // Use edge caching for performance
-         * const cachedUsers = await api.joomla.users.list({
-         *   edgeCache: 2,  // Cache for 2 hours
-         *   limit: 50
-         * });
-         * ```
          */
-        list: (params?: {
-            edgeCache?: 3 | 2 | 4 | 1 | "1" | 5 | 8 | "2" | "3" | "4" | "5" | "8" | undefined;
-            limit?: number | undefined;
-            offset?: number | undefined;
-        } | undefined) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: unknown[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
+        get: () => Promise<HealthCheckResponse>;
         /**
-         * Get user details by ID
-         * @description Returns detailed information for a specific user including profile data and metadata
-         * @fullPath api.joomla.users.get
+         * Get service health data only - /health-check GET (data method)
+         * @fullPath api.joomla.healthCheck.getData
          * @service joomla
-         * @domain user-management
-         * @dataMethod getData(userId, params) - returns only the user object without metadata
-         * @caching Supports edgeCache parameter (1-8 hours) for improved performance
+         * @domain system
+         * @dataMethod getData() - returns only the health data without metadata
          * @discoverable true
-         * @searchTerms ["get user", "user details", "user profile", "user by id", "single user"]
-         * @relatedEndpoints ["api.joomla.users.list", "api.joomla.users.getDoc", "api.joomla.users.getTrinityDoc"]
-         * @commonPatterns ["get user by id", "fetch user profile", "user details lookup"]
-         * @param userId User ID (number or string) - the unique identifier for the user
-         * @param params Optional caching parameters
-         * @param params.edgeCache Cache duration in hours (1, 2, 3, 4, 5, 8) for improved performance
-         * @returns BaseResponse<User> with complete user details and metadata
-         * @throws ValidationError When userId is invalid or response is malformed
-         * @example
-         * ```typescript
-         * // Get user with full response metadata
-         * const response = await api.joomla.users.get(123);
-         * console.log('User:', response.data.username, response.data.email);
-         * console.log('Status:', response.status, response.message);
-         *
-         * // Get just user data without metadata
-         * const user = await api.joomla.users.getData(123);
-         * console.log(user.username, user.email, user.registerDate);
-         *
-         * // Use edge caching for frequently accessed users
-         * const cachedUser = await api.joomla.users.get(123, { edgeCache: 1 });
-         * ```
-         */
-        get: (userId: number | string) => Promise<GenericResponse>;
-        /**
-         * Get user documentation
-         * @description Returns enhanced user document with profile values, customer information, and metadata
-         * @param userId User ID (number or string)
-         * @returns Enhanced user document with profile data
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * const userDoc = await client.users.getDoc(123);
-         * console.log(userDoc.username, userDoc.email, userDoc.customerId);
-         * console.log(userDoc.profileValues?.['simpleweb_customer.simpleweb_customer_companyname']);
-         * ```
-         */
-        getDoc: (userId: number | string) => Promise<GenericResponse>;
-        /**
-         * Get Trinity user documentation
-         * @description Returns specialized Trinity business logic document with territory assignment and role detection
-         * @param userId User ID (number or string)
-         * @param params Optional filtering and pagination parameters
-         * @returns Trinity document with profile, role, groups, and territory information
-         * @throws ValidationError When parameters are invalid or response is malformed
-         * @example
-         * ```typescript
-         * const trinity = await client.users.getTrinityDoc(123);
-         * console.log(trinity.profile.companyName, trinity.territory, trinity.role);
-         *
-         * // With filtering
-         * const filtered = await client.users.getTrinityDoc(123, { q: 'search', limit: 5 });
-         * ```
+         * @searchTerms ["health data", "service health data", "health check data"]
+         * @relatedEndpoints ["api.joomla.healthCheck.get"]
+         * @commonPatterns ["extract health data", "get health status only"]
          */
-        getTrinityDoc: (userId: number | string, params?: BaseGetParams) => Promise<GenericResponse>;
-        /**
-         * User groups sub-endpoints
-         * @description Methods for managing user group memberships and relationships
-         */
-        groups: {
+        getData: () => Promise<{
+            siteHash: string;
+            siteId: string;
+        }>;
+    };
+    /**
+     * Menu endpoints - /menu/{id}/doc
+     */
+    menu: {
+        doc: {
             /**
-             * Get user's group memberships
-             * @description Returns all groups that a specific user belongs to with membership details
-             * @fullPath api.joomla.users.groups.list
+             * Get menu document - /menu/{id}/doc GET
+             * @fullPath api.joomla.menu.doc.get
              * @service joomla
-             * @domain user-management
-             * @dataMethod listData(userId, params) - returns only the group memberships array without metadata
+             * @domain menu-management
+             * @dataMethod getData() - returns only the menu data without metadata
              * @discoverable true
-             * @searchTerms ["user groups", "group membership", "user permissions", "user roles"]
-             * @relatedEndpoints ["api.joomla.userGroups.list", "api.joomla.users.groups.createMapping", "api.joomla.users.get"]
-             * @commonPatterns ["get user groups", "user permissions", "group membership", "user roles"]
-             * @param userId User ID (string) - the unique identifier for the user
-             * @param params Optional pagination parameters
-             * @param params.limit Maximum number of group memberships to return (default: 20)
-             * @param params.offset Number of memberships to skip for pagination (default: 0)
-             * @returns BaseResponse<UserGroupMembership[]> with group membership details and metadata
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * // Get user's groups with full response metadata
-             * const response = await api.joomla.users.groups.list('123');
-             * response.data.forEach(group => {
-             *   console.log(`Group: ${group.title} (ID: ${group.groupId})`);
-             * });
-             *
-             * // Get just group memberships data without metadata
-             * const groups = await api.joomla.users.groups.listData('123');
-             * groups.forEach(group => console.log(group.title, group.groupId));
-             * ```
-             */
-            list: (userId: string, params?: BaseGetParams) => Promise<GenericResponse>;
-            /**
-             * Get specific user group membership
-             * @description Returns detailed information about a user's membership in a specific group
-             * @param userId User ID (string)
-             * @param groupId Group ID (number or string)
-             * @returns User group membership details
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const membership = await client.users.groups.get('123', 1);
-             * console.log(membership.groupTitle, membership.memberSince);
-             * ```
-             */
-            get: (userId: string, groupId: number | string) => Promise<GenericResponse>;
-            /**
-             * Create or update user group mapping
-             * @description Adds or updates a user's membership in a group
-             * @param userId User ID (number or string)
-             * @param request Group mapping request data
-             * @returns Created or updated group mapping information
-             * @throws ValidationError When request is invalid or response is malformed
-             * @example
-             * ```typescript
-             * const mapping = await client.users.groups.createMapping(123, { groupId: 5 });
-             * console.log(mapping.created ? 'Created' : 'Updated', 'group mapping');
-             * ```
+             * @searchTerms ["menu document", "menu doc", "menu item document"]
+             * @relatedEndpoints ["api.joomla.content.doc.get"]
+             * @commonPatterns ["get menu document", "fetch menu item details"]
              */
-            createMapping: (userId: number | string, request: unknown) => Promise<GenericResponse>;
+            get: (menuId: string) => Promise<MenuIdDocResponse>;
             /**
-             * Get user's groups (data only)
-             * @description Returns only the data array from user group memberships response
-             * @param userId User ID (string)
-             * @param params Optional pagination parameters
-             * @returns Array of user group memberships (data only)
-             * @throws ValidationError When response is malformed
-             */
-            listData: (userId: string, params?: BaseGetParams) => Promise<unknown>;
-            /**
-             * Get specific user group membership (data only)
-             * @description Returns only the data from user group membership details response
-             * @param userId User ID (string)
-             * @param groupId Group ID (number or string)
-             * @returns User group membership details (data only)
-             * @throws ValidationError When response is malformed
-             */
-            getData: (userId: string, groupId: number | string) => Promise<unknown>;
-            /**
-             * Create or update user group mapping (data only)
-             * @description Returns only the data from created/updated group mapping response
-             * @param userId User ID (number or string)
-             * @param request Group mapping request data
-             * @returns Group mapping information (data only)
-             * @throws ValidationError When request is invalid or response is malformed
+             * Get menu document data only - /menu/{id}/doc GET (data method)
+             * @fullPath api.joomla.menu.doc.getData
+             * @service joomla
+             * @domain menu-management
+             * @dataMethod getData() - returns only the menu data without metadata
+             * @discoverable true
+             * @searchTerms ["menu document data", "menu doc data", "menu item data"]
+             * @relatedEndpoints ["api.joomla.menu.doc.get"]
+             * @commonPatterns ["extract menu data", "get menu document data only"]
              */
-            createMappingData: (userId: number | string, request: unknown) => Promise<unknown>;
+            getData: (menuId: string) => Promise<{
+                link: string;
+                path: string;
+                type: string;
+                id: number;
+                title: string;
+                alias: string;
+                access: number;
+                language: string;
+                ordering: number;
+                published: number;
+                parent_id: number;
+                level: number;
+                component_id: number;
+                checked_out: number;
+                checked_out_time: string;
+                browserNav: number;
+                img: string;
+                template_style_id: number;
+                lft: number;
+                rgt: number;
+                home: number;
+                client_id: number;
+                params?: Record<string, unknown> | undefined;
+            }>;
         };
+    };
+    /**
+     * Tags endpoints - /tags
+     */
+    tags: {
         /**
-         * Verify user credentials and authenticate
-         * @description Verifies username/password combination and returns authentication token, supports cross-site authentication
-         * @fullPath api.joomla.users.verifyPassword
+         * List content tags
+         * @fullPath api.joomla.tags.get
          * @service joomla
-         * @domain authentication
-         * @dataMethod verifyPasswordData(request) - returns only the verification result without metadata
-         * @crossSite Supports authentication across multiple sites when called from 'augur_info' site
+         * @domain content-management
+         * @dataMethod getData() - returns only the tags array without metadata
          * @discoverable true
-         * @searchTerms ["verify password", "authenticate", "login", "user authentication", "credentials", "sign in"]
-         * @relatedEndpoints ["api.joomla.users.get", "api.joomla.users.create", "api.customers.customer.get"]
-         * @commonPatterns ["user login", "authenticate user", "verify credentials", "password check"]
-         * @param request Authentication request containing username, password, and optional siteId
-         * @param request.username User's username for authentication
-         * @param request.password User's password for verification
-         * @param request.siteId Optional site ID for cross-site authentication (when using augur_info)
-         * @returns BaseResponse<VerifyPasswordResult> with verification status, user info, and JWT token
-         * @throws ValidationError When credentials are invalid or request is malformed
-         * @example
-         * ```typescript
-         * // Standard authentication with full response
-         * const response = await api.joomla.users.verifyPassword({
-         *   username: 'johndoe',
-         *   password: 'securePassword123'
-         * });
-         *
-         * if (response.data.verified) {
-         *   console.log('Login successful:', response.data.username);
-         *   console.log('JWT Token:', response.data.token);
-         *   console.log('User ID:', response.data.userId);
-         * }
-         *
-         * // Cross-site authentication (when using augur_info site)
-         * const crossSiteAuth = await api.joomla.users.verifyPassword({
-         *   username: 'johndoe',
-         *   password: 'securePassword123',
-         *   siteId: 'customer_site_1'
-         * });
-         *
-         * // Get just verification data without metadata
-         * const authResult = await api.joomla.users.verifyPasswordData({
-         *   username: 'johndoe',
-         *   password: 'securePassword123'
-         * });
-         * ```
          */
-        verifyPassword: (request: VerifyPasswordRequest) => Promise<VerifyPasswordResponse>;
+        get: (params?: TagsParams) => Promise<TagsResponse>;
         /**
-         * Create a new user account
-         * @description Creates a new user account in the system with username, email, name, and password
-         * @fullPath api.joomla.users.create
+         * Get tags data only - /tags GET (data method)
+         * @fullPath api.joomla.tags.getData
+         * @service joomla
+         * @domain content-management
+         * @dataMethod getData() - returns only the tags array without metadata
+         * @discoverable true
+         * @searchTerms ["tags data", "content tags data", "get tags data only"]
+         * @relatedEndpoints ["api.joomla.tags.get"]
+         * @commonPatterns ["extract tags data", "get content tags data only"]
+         */
+        getData: (params?: TagsParams) => Promise<{
+            path: string;
+            description: string;
+            id: number;
+            title: string;
+            alias: string;
+            access: number;
+            language: string;
+            hits: number;
+            published: number;
+            parent_id: number;
+            level: number;
+            created_user_id: number;
+            created_time: string;
+            modified_user_id: number;
+            modified_time: string;
+            images?: string | undefined;
+            urls?: string | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            note?: string | undefined;
+        }[]>;
+    };
+    /**
+     * Users endpoints - /users
+     */
+    users: {
+        /**
+         * List users - /users GET
+         * @fullPath api.joomla.users.get
+         * @service joomla
+         * @domain user-management
+         * @dataMethod getData() - returns only the users array without metadata
+         * @discoverable true
+         * @searchTerms ["users", "list users", "get users", "user management", "user list"]
+         * @relatedEndpoints ["api.joomla.users.create", "api.joomla.users.getById"]
+         * @commonPatterns ["list all users", "get user list", "user management"]
+         */
+        get: (params?: UsersParams) => Promise<UsersResponse>;
+        /**
+         * Get users data only - /users GET (data method)
+         * @fullPath api.joomla.users.getData
          * @service joomla
          * @domain user-management
-         * @dataMethod createData(request) - returns only the created user object without metadata
+         * @dataMethod getData() - returns only the users array without metadata
          * @discoverable true
-         * @searchTerms ["create user", "new user", "user registration", "add user", "register user"]
-         * @relatedEndpoints ["api.joomla.users.list", "api.joomla.users.get", "api.joomla.users.verifyPassword"]
-         * @commonPatterns ["register new user", "create account", "add user account", "user signup"]
-         * @param request User creation request data including username, email, name, and password
-         * @param request.username Unique username for the new user (required)
-         * @param request.email Valid email address for the user (required)
-         * @param request.name Full display name for the user (required)
-         * @param request.password Secure password for the user (required, minimum 8 characters)
-         * @returns BaseResponse<User> with created user information including ID, username, and email
-         * @throws ValidationError When request is invalid or response is malformed
-         * @example
-         * ```typescript
-         * // Create new user with full response metadata
-         * const response = await api.joomla.users.create({
-         *   username: 'newuser',
-         *   email: 'user@example.com',
-         *   name: 'New User',
-         *   password: 'SecurePass123!'
-         * });
-         * console.log('Created user:', response.data.id, response.data.username);
-         * console.log('Status:', response.status, response.message);
-         *
-         * // Get just created user data without metadata
-         * const newUser = await api.joomla.users.createData({
-         *   username: 'johndoe',
-         *   email: 'john@example.com',
-         *   name: 'John Doe',
-         *   password: 'MySecurePassword123!'
-         * });
-         * console.log('New user ID:', newUser.id, 'Email:', newUser.email);
-         * ```
+         * @searchTerms ["users data", "get users data", "user list data"]
+         * @relatedEndpoints ["api.joomla.users.get"]
+         * @commonPatterns ["extract users data", "get user list data only"]
          */
-        create: (data: {
+        getData: (params?: UsersParams) => Promise<{
+            params: string;
+            id: number;
+            name: string;
             username: string;
             email: string;
-            password?: string | undefined;
-            name?: string | undefined;
+            block: number;
+            sendEmail: number;
+            registerDate: string;
+            lastvisitDate: string | null;
+            activation: string;
             groups?: number[] | undefined;
-            profileValues?: Record<string, string> | undefined;
-        }) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-            data?: unknown;
-        }>;
+            customerId?: number | undefined;
+        }[]>;
         /**
-         * Update an existing user
-         * @description Updates user information for an existing user account
-         * @param userId User ID (number or string)
-         * @param request User update data with optional fields to modify
-         * @returns Updated user object with all current information
-         * @throws ValidationError When request is invalid or response is malformed
-         * @example
-         * ```typescript
-         * const updatedUser = await client.users.update(123, {
-         *   email: 'newemail@example.com',
-         *   name: 'Updated Name',
-         *   block: 0 // Unblock user
-         * });
-         * console.log('Updated user:', updatedUser.username, updatedUser.email);
-         * ```
+         * Create user - /users POST
+         * @fullPath api.joomla.users.create
+         * @service joomla
+         * @domain user-management
+         * @dataMethod createData() - returns only the created user data without metadata
+         * @discoverable true
+         * @searchTerms ["create user", "add user", "new user", "user creation"]
+         * @relatedEndpoints ["api.joomla.users.get", "api.joomla.users.update"]
+         * @commonPatterns ["create new user account", "add user to system", "user registration"]
          */
-        update: (id: string | number, data: {
-            username?: string | undefined;
-            password?: string | undefined;
-            email?: string | undefined;
-            name?: string | undefined;
-            profileValues?: Record<string, string | string[]> | undefined;
-        }) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-            data?: unknown;
-        }>;
+        create: (request: UsersCreateRequest) => Promise<UsersCreateResponse>;
         /**
-         * Block (deactivate) a user
-         * @description Blocks a user account without deleting it, preventing user access to the system
-         * @param userId User ID (number or string)
-         * @returns Boolean indicating successful blocking operation
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * const blocked = await client.users.block(123);
-         * if (blocked) {
-         *   console.log('User has been successfully blocked');
-         * }
-         * ```
+         * Create user data only - /users POST (data method)
+         * @fullPath api.joomla.users.createData
+         * @service joomla
+         * @domain user-management
+         * @dataMethod createData() - returns only the created user data without metadata
+         * @discoverable true
+         * @searchTerms ["create user data", "add user data", "user creation data"]
+         * @relatedEndpoints ["api.joomla.users.create"]
+         * @commonPatterns ["extract created user data", "get new user data only"]
          */
-        block: (id: string | number) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
+        createData: (request: UsersCreateRequest) => Promise<{
             message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-            data?: unknown;
+            id: number;
+            created: boolean;
+            name: string;
+            username: string;
+            email: string;
         }>;
         /**
-         * Retrieve a paginated list of users (data only)
-         * @description Returns only the data array from users response
-         * @param params Optional filtering, pagination, and caching parameters
-         * @returns Array of users (data only)
-         * @throws ValidationError When parameters are invalid or response is malformed
-         */
-        listData: (params?: BaseGetParams) => Promise<unknown[]>;
-        /**
-         * Get user details by ID (data only)
-         * @description Returns only the data from user details response
-         * @param userId User ID (number or string)
-         * @param params Optional caching parameters
-         * @returns User details (data only)
-         * @throws ValidationError When response is malformed
-         */
-        getData: (userId: number | string) => Promise<unknown>;
-        /**
-         * Get user documentation (data only)
-         * @description Returns only the data from enhanced user document response
-         * @param userId User ID (number or string)
-         * @returns Enhanced user document (data only)
-         * @throws ValidationError When response is malformed
-         */
-        getDocData: (userId: number | string) => Promise<unknown>;
-        /**
-         * Get Trinity user documentation (data only)
-         * @description Returns only the data from specialized Trinity business logic document response
-         * @param userId User ID (number or string)
-         * @param params Optional filtering and pagination parameters
-         * @returns Trinity document (data only)
-         * @throws ValidationError When parameters are invalid or response is malformed
+         * Get user by ID - /users/{id} GET
+         * @fullPath api.joomla.users.getById
+         * @service joomla
+         * @domain user-management
+         * @dataMethod getByIdData() - returns only the user data without metadata
+         * @discoverable true
+         * @searchTerms ["user by id", "get user", "single user", "user details"]
+         * @relatedEndpoints ["api.joomla.users.get", "api.joomla.users.update", "api.joomla.users.delete"]
+         * @commonPatterns ["get user details", "fetch user by id", "user profile"]
          */
-        getTrinityDocData: (userId: number | string, params?: BaseGetParams) => Promise<unknown>;
+        getById: (userId: number | string) => Promise<UsersIdResponse>;
         /**
-         * Verify user password (data only)
-         * @description Returns only the data from password verification response
-         * @param request Object containing username, password, and optional siteId for cross-site auth
-         * @returns Verification result (data only)
+         * Get user by ID data only - /users/{id} GET (data method)
+         * @fullPath api.joomla.users.getByIdData
+         * @service joomla
+         * @domain user-management
+         * @dataMethod getByIdData() - returns only the user data without metadata
+         * @discoverable true
+         * @searchTerms ["user data by id", "get user data", "single user data"]
+         * @relatedEndpoints ["api.joomla.users.getById"]
+         * @commonPatterns ["extract user data", "get user data only"]
          */
-        verifyPasswordData: (request: VerifyPasswordRequest) => Promise<{
+        getByIdData: (userId: number | string) => Promise<{
+            params: string;
             id: number;
+            name: string;
             username: string;
-            isVerified: boolean;
-            token: string;
             email: string;
+            block: number;
+            sendEmail: number;
+            registerDate: string;
+            lastvisitDate: string | null;
+            activation: string;
+            lastResetTime: string | null;
+            resetCount: number;
+            otpKey: string;
+            otep: string;
+            requireReset: number;
+            authProvider?: string | undefined;
+            groups?: number[] | undefined;
+            profileValues?: Record<string, unknown> | undefined;
         }>;
         /**
-         * Create a new user (data only)
-         * @description Returns only the data from created user response
-         * @param request User creation request data including username, email, name, and password
-         * @returns Created user information (data only)
-         * @throws ValidationError When request is invalid or response is malformed
-         */
-        createData: (request: CreateUserRequest) => Promise<unknown>;
-        /**
-         * Update an existing user (data only)
-         * @description Returns only the data from updated user response
-         * @param userId User ID (number or string)
-         * @param request User update data with optional fields to modify
-         * @returns Updated user object (data only)
-         * @throws ValidationError When request is invalid or response is malformed
+         * Update user - /users/{id} PUT
+         * @fullPath api.joomla.users.update
+         * @service joomla
+         * @domain user-management
+         * @dataMethod updateData() - returns only the updated user data without metadata
+         * @discoverable true
+         * @searchTerms ["update user", "edit user", "modify user", "user update"]
+         * @relatedEndpoints ["api.joomla.users.getById", "api.joomla.users.get"]
+         * @commonPatterns ["update user profile", "edit user details", "modify user account"]
          */
-        updateData: (userId: number | string, request: UpdateUserRequest) => Promise<unknown>;
+        update: (userId: number | string, request: UsersIdUpdateRequest) => Promise<UsersIdUpdateResponse>;
         /**
-         * Block (deactivate) a user (data only)
-         * @description Returns only the data from user blocking response
-         * @param userId User ID (number or string)
-         * @returns Blocking operation result (data only)
-         * @throws ValidationError When response is malformed
-         */
-        blockData: (userId: number | string) => Promise<unknown>;
-    };
-    /**
-     * User Groups endpoints
-     * @description Methods for managing system-wide user groups and their hierarchy
-     */
-    userGroups: {
-        /**
-         * Get hierarchical list of user groups
-         * @description Returns system-wide user groups with hierarchy information, filtering, and caching
-         * @fullPath api.joomla.userGroups.list
+         * Update user data only - /users/{id} PUT (data method)
+         * @fullPath api.joomla.users.updateData
          * @service joomla
          * @domain user-management
-         * @dataMethod listData(params) - returns only the user groups array without metadata
-         * @hierarchy Returns groups with level and parent relationship information
-         * @caching Supports edgeCache parameter (1-8 hours) - recommended since groups rarely change
+         * @dataMethod updateData() - returns only the updated user data without metadata
          * @discoverable true
-         * @searchTerms ["user groups", "groups", "permissions", "roles", "group hierarchy", "user roles"]
-         * @relatedEndpoints ["api.joomla.users.groups.list", "api.joomla.users.list", "api.joomla.users.groups.createMapping"]
-         * @commonPatterns ["list user groups", "get groups", "group permissions", "user roles", "group hierarchy"]
-         * @param params Optional filtering, ordering, and caching parameters
-         * @param params.orderBy Sort order (e.g., 'title|ASC', 'title|DESC', 'level|ASC')
-         * @param params.parentIdList Comma-separated list of parent group IDs to filter (e.g., '1,2')
-         * @param params.edgeCache Cache duration in hours (1-8) - highly recommended since groups rarely change
-         * @returns BaseResponse<UserGroup[]> with hierarchy metadata and groups array
-         * @throws ValidationError When parameters are invalid or response is malformed
-         * @example
-         * ```typescript
-         * // Get all user groups with hierarchy information
-         * const response = await api.joomla.userGroups.list();
-         * response.data.forEach(group => {
-         *   console.log(`${group.title} (Level: ${group.level}, Parent: ${group.parentId})`);
-         * });
-         *
-         * // Filter and order groups
-         * const ordered = await api.joomla.userGroups.list({
-         *   orderBy: 'title|ASC',
-         *   parentIdList: '1,2'
-         * });
-         *
-         * // Get just groups data without metadata
-         * const groups = await api.joomla.userGroups.listData({
-         *   orderBy: 'level|ASC'
-         * });
-         *
-         * // Use long caching since groups rarely change
-         * const cachedGroups = await api.joomla.userGroups.list({
-         *   edgeCache: 8,  // Cache for 8 hours - groups change very infrequently
-         *   orderBy: 'title|ASC'
-         * });
-         * ```
+         * @searchTerms ["update user data", "edit user data", "modify user data"]
+         * @relatedEndpoints ["api.joomla.users.update"]
+         * @commonPatterns ["extract updated user data", "get updated user data only"]
          */
-        list: (params?: BaseGetParams) => Promise<GenericResponse>;
+        updateData: (userId: number | string, request: UsersIdUpdateRequest) => Promise<{
+            params: string;
+            id: number;
+            name: string;
+            username: string;
+            email: string;
+            block: number;
+            sendEmail: number;
+            registerDate: string;
+            lastvisitDate: string | null;
+            activation: string;
+            lastResetTime: string | null;
+            resetCount: number;
+            otpKey: string;
+            otep: string;
+            requireReset: number;
+            authProvider?: string | undefined;
+            groups?: number[] | undefined;
+            profileValues?: Record<string, unknown> | undefined;
+        }>;
         /**
-         * Get user groups (data only)
-         * @description Returns only the data array from user groups response
-         * @param params Optional filtering, ordering, and caching parameters
-         * @returns Array of user groups (data only)
-         * @throws ValidationError When parameters are invalid or response is malformed
+         * Delete user - /users/{id} DELETE
+         * @fullPath api.joomla.users.delete
+         * @service joomla
+         * @domain user-management
+         * @dataMethod deleteData() - returns only the deletion result data without metadata
+         * @discoverable true
+         * @searchTerms ["delete user", "remove user", "user deletion"]
+         * @relatedEndpoints ["api.joomla.users.getById", "api.joomla.users.get"]
+         * @commonPatterns ["delete user account", "remove user", "deactivate user"]
          */
-        listData: (params?: BaseGetParams) => Promise<unknown>;
-    };
-    /**
-     * Tags endpoints
-     * @description Methods for managing content tags and their hierarchical relationships
-     */
-    tags: {
+        delete: (userId: number | string) => Promise<UsersIdDeleteResponse>;
         /**
-         * Get hierarchical list of content tags
-         * @description Returns content tags with hierarchy, usage information, filtering, search, and edge caching
-         * @fullPath api.joomla.tags.list
+         * Delete user data only - /users/{id} DELETE (data method)
+         * @fullPath api.joomla.users.deleteData
          * @service joomla
-         * @domain content-management
-         * @dataMethod listData(params) - returns only the tags array without metadata
-         * @hierarchy Returns tags with level and parent relationship information
-         * @caching Supports edgeCache parameter (1-8 hours) - recommended for reference data
+         * @domain user-management
+         * @dataMethod deleteData() - returns only the deletion result data without metadata
          * @discoverable true
-         * @searchTerms ["tags", "content tags", "taxonomy", "categories", "tag hierarchy"]
-         * @relatedEndpoints ["api.joomla.content.list", "api.joomla.content.get", "api.joomla.userGroups.list"]
-         * @commonPatterns ["list tags", "get tags", "search tags", "content taxonomy", "tag filtering"]
-         * @param params Optional filtering, search, and caching parameters
-         * @param params.q Search query for filtering tags by title
-         * @param params.catId Category ID to filter tags by category
-         * @param params.limit Maximum number of tags to return (default: 20, max: 100)
-         * @param params.offset Number of tags to skip for pagination (default: 0)
-         * @param params.edgeCache Cache duration in hours (1-8) - recommended for reference data
-         * @returns BaseResponse<Tag[]> with hierarchy metadata and tags array
-         * @throws ValidationError When parameters are invalid or response is malformed
-         * @example
-         * ```typescript
-         * // Get all tags with hierarchy information
-         * const response = await api.joomla.tags.list();
-         * response.data.forEach(tag => {
-         *   console.log(`${tag.title} (${tag.hits} hits, Level: ${tag.level})`);
-         * });
-         *
-         * // Search tags by keyword
-         * const searchTags = await api.joomla.tags.list({
-         *   q: 'technology',
-         *   catId: 1,
-         *   limit: 10
-         * });
-         *
-         * // Get just tags data without metadata
-         * const tags = await api.joomla.tags.listData({
-         *   limit: 50
-         * });
-         * tags.forEach(tag => console.log(tag.title, tag.alias));
-         *
-         * // Use caching for reference data (recommended)
-         * const cachedTags = await api.joomla.tags.list({
-         *   edgeCache: 5,  // Cache for 5 hours - tags are reference data
-         *   limit: 100
-         * });
-         * ```
+         * @searchTerms ["delete user data", "remove user data", "user deletion data"]
+         * @relatedEndpoints ["api.joomla.users.delete"]
+         * @commonPatterns ["extract deletion result", "get deletion data only"]
          */
-        list: (params?: {
-            edgeCache?: 3 | 2 | 4 | 1 | "1" | 5 | 8 | "2" | "3" | "4" | "5" | "8" | undefined;
-            limit?: number | undefined;
-            offset?: number | undefined;
-        } | undefined) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: unknown[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
+        deleteData: (userId: number | string) => Promise<{
             message: string;
-            count: number;
-            total: number;
-            totalResults: number;
+            id: number;
+            blocked: boolean;
         }>;
         /**
-         * Get tags (data only)
-         * @description Returns only the data array from tags response
-         * @param params Optional filtering, search, and caching parameters
-         * @returns Array of tags (data only)
-         * @throws ValidationError When parameters are invalid or response is malformed
+         * User document - /users/{id}/doc
+         */
+        doc: {
+            /**
+             * Get user document - /users/{id}/doc GET
+             * @fullPath api.joomla.users.doc.get
+             * @service joomla
+             * @domain user-management
+             * @dataMethod getData() - returns only the user document data without metadata
+             * @discoverable true
+             * @searchTerms ["user document", "user doc", "user full document"]
+             * @relatedEndpoints ["api.joomla.users.getById"]
+             * @commonPatterns ["get user document", "fetch user full details"]
+             */
+            get: (userId: number | string) => Promise<UsersIdDocResponse>;
+            /**
+             * Get user document data only - /users/{id}/doc GET (data method)
+             * @fullPath api.joomla.users.doc.getData
+             * @service joomla
+             * @domain user-management
+             * @dataMethod getData() - returns only the user document data without metadata
+             * @discoverable true
+             * @searchTerms ["user document data", "user doc data", "user full document data"]
+             * @relatedEndpoints ["api.joomla.users.doc.get"]
+             * @commonPatterns ["extract user document data", "get user document data only"]
+             */
+            getData: (userId: number | string) => Promise<{
+                id: number;
+                name: string;
+                username: string;
+                email: string;
+                block: number;
+                sendEmail: number;
+                registerDate: string;
+                lastvisitDate: string | null;
+                activation: string;
+                params?: Record<string, unknown> | undefined;
+                permissions?: string[] | undefined;
+                groups?: {
+                    id: number;
+                    title: string;
+                    level: number;
+                }[] | undefined;
+                profileValues?: Record<string, unknown> | undefined;
+                customerId?: number | undefined;
+                customerInfo?: {
+                    companyName?: string | undefined;
+                    territory?: string | undefined;
+                    role?: string | undefined;
+                } | undefined;
+            }>;
+        };
+        /**
+         * Trinity user document - /users/{id}/trinity
          */
-        listData: (params?: BaseGetParams) => Promise<unknown[]>;
+        trinity: {
+            /**
+             * Get trinity user document - /users/{id}/trinity GET
+             * @fullPath api.joomla.users.trinity.get
+             * @service joomla
+             * @domain user-management
+             * @dataMethod getData() - returns only the trinity user data without metadata
+             * @discoverable true
+             * @searchTerms ["trinity user", "user trinity", "trinity document"]
+             * @relatedEndpoints ["api.joomla.users.doc.get", "api.joomla.users.getById"]
+             * @commonPatterns ["get trinity user data", "fetch user trinity document"]
+             */
+            get: (userId: number | string, params?: UsersIdTrinityParams) => Promise<UsersIdTrinityResponse>;
+            /**
+             * Get trinity user document data only - /users/{id}/trinity GET (data method)
+             * @fullPath api.joomla.users.trinity.getData
+             * @service joomla
+             * @domain user-management
+             * @dataMethod getData() - returns only the trinity user data without metadata
+             * @discoverable true
+             * @searchTerms ["trinity user data", "user trinity data", "trinity document data"]
+             * @relatedEndpoints ["api.joomla.users.trinity.get"]
+             * @commonPatterns ["extract trinity user data", "get trinity data only"]
+             */
+            getData: (userId: number | string, params?: UsersIdTrinityParams) => Promise<{
+                id: number;
+                permissions: string[];
+                groups: {
+                    id: number;
+                    title: string;
+                    level: number;
+                    isDefault?: boolean | undefined;
+                }[];
+                profile: {
+                    userId: number;
+                    email: string;
+                    companyName?: string | undefined;
+                    territory?: string | undefined;
+                    role?: string | undefined;
+                    firstName?: string | undefined;
+                    lastName?: string | undefined;
+                    phone?: string | undefined;
+                };
+                territory?: {
+                    code: string;
+                    name: string;
+                    region?: string | undefined;
+                } | undefined;
+                role?: {
+                    level: string;
+                    name: string;
+                    capabilities: string[];
+                } | undefined;
+                businessLogic?: Record<string, unknown> | undefined;
+            }>;
+        };
+        /**
+         * User groups - /users/{id}/groups
+         */
+        groups: {
+            /**
+             * List user groups - /users/{id}/groups GET
+             * @fullPath api.joomla.users.groups.get
+             * @service joomla
+             * @domain user-management
+             * @dataMethod getData() - returns only the user groups array without metadata
+             * @discoverable true
+             * @searchTerms ["user groups", "user group list", "groups for user"]
+             * @relatedEndpoints ["api.joomla.users.groups.create", "api.joomla.userGroups.get"]
+             * @commonPatterns ["get user groups", "list user group memberships"]
+             */
+            get: (userId: string, params?: UsersIdGroupsParams) => Promise<UsersIdGroupsResponse>;
+            /**
+             * Get user groups data only - /users/{id}/groups GET (data method)
+             * @fullPath api.joomla.users.groups.getData
+             * @service joomla
+             * @domain user-management
+             * @dataMethod getData() - returns only the user groups array without metadata
+             * @discoverable true
+             * @searchTerms ["user groups data", "user group list data", "groups data"]
+             * @relatedEndpoints ["api.joomla.users.groups.get"]
+             * @commonPatterns ["extract user groups data", "get groups data only"]
+             */
+            getData: (userId: string, params?: UsersIdGroupsParams) => Promise<{
+                parent_id: number;
+                level: number;
+                userId: number;
+                groupId: number;
+                groupTitle: string;
+                memberSince: string;
+                isActive: boolean;
+                groupDescription?: string | undefined;
+                permissions?: string[] | undefined;
+            }[]>;
+            /**
+             * Create user group mapping - /users/{id}/groups POST
+             * @fullPath api.joomla.users.groups.create
+             * @service joomla
+             * @domain user-management
+             * @dataMethod createData() - returns only the created group mapping data without metadata
+             * @discoverable true
+             * @searchTerms ["add user to group", "create user group mapping", "assign user group"]
+             * @relatedEndpoints ["api.joomla.users.groups.get", "api.joomla.users.groups.getById"]
+             * @commonPatterns ["add user to group", "assign group membership", "create group mapping"]
+             */
+            create: (userId: number | string, request: UsersIdGroupsCreateRequest) => Promise<UsersIdGroupsCreateResponse>;
+            /**
+             * Create user group mapping data only - /users/{id}/groups POST (data method)
+             * @fullPath api.joomla.users.groups.createData
+             * @service joomla
+             * @domain user-management
+             * @dataMethod createData() - returns only the created group mapping data without metadata
+             * @discoverable true
+             * @searchTerms ["add user to group data", "create group mapping data", "assign user group data"]
+             * @relatedEndpoints ["api.joomla.users.groups.create"]
+             * @commonPatterns ["extract group mapping data", "get created mapping data only"]
+             */
+            createData: (userId: number | string, request: UsersIdGroupsCreateRequest) => Promise<{
+                message: string;
+                created: boolean;
+                userId: number;
+                groupId: number;
+            }>;
+            /**
+             * Get specific user group - /users/{id}/groups/{groupId} GET
+             * @fullPath api.joomla.users.groups.getById
+             * @service joomla
+             * @domain user-management
+             * @dataMethod getByIdData() - returns only the user group data without metadata
+             * @discoverable true
+             * @searchTerms ["user group by id", "specific user group", "user group details"]
+             * @relatedEndpoints ["api.joomla.users.groups.get", "api.joomla.userGroups.get"]
+             * @commonPatterns ["get specific user group", "fetch user group details"]
+             */
+            getById: (userId: string, groupId: number | string) => Promise<UsersIdGroupsGroupIdResponse>;
+            /**
+             * Get specific user group data only - /users/{id}/groups/{groupId} GET (data method)
+             * @fullPath api.joomla.users.groups.getByIdData
+             * @service joomla
+             * @domain user-management
+             * @dataMethod getByIdData() - returns only the user group data without metadata
+             * @discoverable true
+             * @searchTerms ["user group data by id", "specific user group data", "user group details data"]
+             * @relatedEndpoints ["api.joomla.users.groups.getById"]
+             * @commonPatterns ["extract user group data", "get specific group data only"]
+             */
+            getByIdData: (userId: string, groupId: number | string) => Promise<{
+                userId: number;
+                groupId: number;
+                groupTitle: string;
+                memberSince: string;
+                isActive: boolean;
+                groupDescription?: string | undefined;
+                permissions?: string[] | undefined;
+                inheritedGroups?: {
+                    id: number;
+                    title: string;
+                }[] | undefined;
+            }>;
+        };
+        /**
+         * Password verification - /users/verify-password
+         */
+        verifyPassword: {
+            /**
+             * Verify user password - /users/verify-password POST
+             * @fullPath api.joomla.users.verifyPassword.create
+             * @service joomla
+             * @domain user-management
+             * @dataMethod createData() - returns only the verification result data without metadata
+             * @discoverable true
+             * @searchTerms ["verify password", "check password", "authenticate user", "login verification"]
+             * @relatedEndpoints ["api.joomla.users.getById", "api.joomla.users.get"]
+             * @commonPatterns ["verify user password", "authenticate user", "check login credentials"]
+             */
+            create: (request: UsersVerifyPasswordRequest) => Promise<UsersVerifyPasswordResponse>;
+            /**
+             * Verify user password data only - /users/verify-password POST (data method)
+             * @fullPath api.joomla.users.verifyPassword.createData
+             * @service joomla
+             * @domain user-management
+             * @dataMethod createData() - returns only the verification result data without metadata
+             * @discoverable true
+             * @searchTerms ["verify password data", "check password data", "authentication result data"]
+             * @relatedEndpoints ["api.joomla.users.verifyPassword.create"]
+             * @commonPatterns ["extract verification result", "get authentication data only"]
+             */
+            createData: (request: UsersVerifyPasswordRequest) => Promise<{
+                id: number;
+                username: string;
+                email: string;
+                isVerified: boolean;
+                token: string;
+            }>;
+        };
     };
     /**
-     * Menu endpoints
-     * @description Methods for accessing menu structure and navigation documentation
+     * User Groups endpoints - /usergroups
      */
-    menu: {
+    userGroups: {
         /**
-         * Get menu documentation
-         * @description Returns enhanced menu item document with navigation hierarchy information
-         * @param menuId Menu item ID (string)
-         * @returns Complete menu document with navigation structure
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * const menuDoc = await client.menu.getDoc('101');
-         * console.log('Menu:', menuDoc.data.title, menuDoc.data.link);
-         * console.log('Level:', menuDoc.data.level, 'Parent:', menuDoc.data.parentId);
-         * ```
+         * List user groups - /usergroups GET
+         * @fullPath api.joomla.userGroups.get
+         * @service joomla
+         * @domain user-management
+         * @dataMethod getData() - returns only the groups array without metadata
+         * @discoverable true
+         * @searchTerms ["user groups", "list groups", "all groups", "group management"]
+         * @relatedEndpoints ["api.joomla.users.groups.get"]
+         * @commonPatterns ["list all user groups", "get available groups", "group management"]
          */
-        getDoc: (menuId: string) => Promise<GenericResponse>;
+        get: (params?: UserGroupsParams) => Promise<UserGroupsResponse>;
         /**
-         * Get menu documentation (data only)
-         * @description Returns only the data from enhanced menu item document response
-         * @param menuId Menu item ID (string)
-         * @returns Menu document (data only)
-         * @throws ValidationError When response is malformed
+         * Get user groups data only - /usergroups GET (data method)
+         * @fullPath api.joomla.userGroups.getData
+         * @service joomla
+         * @domain user-management
+         * @dataMethod getData() - returns only the groups array without metadata
+         * @discoverable true
+         * @searchTerms ["user groups data", "list groups data", "all groups data"]
+         * @relatedEndpoints ["api.joomla.userGroups.get"]
+         * @commonPatterns ["extract groups data", "get groups data only"]
          */
-        getDocData: (menuId: string) => Promise<unknown>;
+        getData: (params?: UserGroupsParams) => Promise<{
+            id: number;
+            title: string;
+            created: string;
+            created_by: number;
+            modified: string;
+            modified_by: number;
+            access: number;
+            published: number;
+            parent_id: number;
+            level: number;
+            lft: number;
+            rgt: number;
+            description?: string | undefined;
+            note?: string | undefined;
+            rules?: string | undefined;
+        }[]>;
     };
     /**
-     * Check service health (no bearer token required)
-     * @description Monitor service availability without authentication overhead
-     * @returns Health check response with site information
-     * @throws ValidationError When response is malformed
-     * @example
-     * ```typescript
-     * const health = await client.getHealthCheck();
-     * console.log('Service health:', health.status);
-     * console.log('Site ID:', health.data.siteId);
-     * console.log('Site Hash:', health.data.siteHash);
-     * ```
-     */
-    getHealthCheck: () => Promise<{
-        params: Record<string, unknown> | unknown[];
-        data: {
-            siteHash: string;
-            siteId: string;
-        };
-        options: Record<string, unknown> | unknown[];
-        status: number;
-        message: string;
-        count: number;
-        total: number;
-        totalResults: number;
-    }>;
-    /**
-     * Ping test (no bearer token required)
-     * @description Simple connectivity test that returns 'pong'
-     * @returns Ping response containing 'pong' string
-     * @throws ValidationError When response is malformed
-     * @example
-     * ```typescript
-     * const pingResult = await client.ping();
-     * console.log(pingResult); // 'pong'
-     * ```
+     * Ping endpoint (no bearer token required)
      */
     ping: () => Promise<{
         params: Record<string, unknown> | unknown[];
@@ -855,45 +812,13 @@ export declare class JoomlaClient extends BaseServiceClient {
     }>;
     /**
      * Health Data Operations
-     * @description Direct access to health check data without response metadata
      */
     healthData: {
-        /**
-         * Get health check data without response metadata
-         * @returns Promise<unknown> Health status data directly
-         */
         check: () => Promise<{
             siteHash: string;
             siteId: string;
         }>;
-        /**
-         * Get ping data without response metadata
-         * @returns Promise<unknown> Ping response data directly
-         */
         ping: () => Promise<"pong">;
     };
-    /**
-     * Override getDiscoveryMetadata to provide hardcoded endpoint metadata
-     * This works around the JSDoc parsing issue in compiled JavaScript
-     */
-    getDiscoveryMetadata(): {
-        serviceName: string;
-        description: string;
-        baseUrl: string;
-        endpoints: {
-            fullPath: string;
-            service: string;
-            domain: string;
-            method: string;
-            path: string;
-            description: string;
-            searchTerms: string[];
-            relatedEndpoints: string[];
-            commonPatterns: string[];
-            dataMethod: string;
-            discoverable: boolean;
-        }[];
-    };
 }
-export {};
 //# sourceMappingURL=client.d.ts.map