@simpleapps-com/augur-api 0.4.1 → 0.4.3

package/dist/cjs/services/joomla/client.js

@@ -3,10 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JoomlaClient = void 0;
 const base_client_1 = require("../../core/base-client");
 const schemas_1 = require("./schemas");
-const schemas_2 = require("../../core/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';
@@ -15,1038 +14,691 @@ const schemas_2 = require("../../core/schemas");
  * 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' });
  * ```
  */
 class JoomlaClient extends base_client_1.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, baseUrl = 'https://joomla.augur-api.com') {
         super('joomla', http, baseUrl);
         /**
-         * Content endpoints
-         * @description Methods for content management including articles, documents, and metadata
+         * Content endpoints - /content
          */
         this.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: this.createListMethod('/content', schemas_2.BaseGetParamsSchema, schemas_1.GenericListResponseSchema),
+            get: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/content',
+                    paramsSchema: schemas_1.ContentParamsSchema,
+                    responseSchema: schemas_1.ContentResponseSchema,
+                }, params);
+            },
             /**
-             * 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 });
-             * ```
+             * @searchTerms ["content data", "articles data", "get content data", "cms content data"]
+             * @relatedEndpoints ["api.joomla.content.get"]
+             * @commonPatterns ["get content data only", "extract article data"]
              */
-            get: async (contentId, params) => {
+            getData: async (params) => {
+                const response = await this.content.get(params);
+                return response.data;
+            },
+            /**
+             * 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"]
+             */
+            getById: async (contentId, params) => {
                 return this.executeRequest({
                     method: 'GET',
                     path: '/content/{id}',
-                    paramsSchema: schemas_2.BaseGetParamsSchema,
-                    responseSchema: schemas_1.GenericResponseSchema,
+                    paramsSchema: schemas_1.ContentIdParamsSchema,
+                    responseSchema: schemas_1.ContentIdResponseSchema,
                 }, params, { id: String(contentId) });
             },
             /**
-             * 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);
-             * ```
-             */
-            getDoc: this.createDocMethod('/content/{id}/doc', schemas_1.GenericResponseSchema),
-            /**
-             * 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
-             */
-            listData: async (params) => {
-                const response = await this.content.list(params);
-                return response.data;
-            },
-            /**
-             * 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: async (contentId, params) => {
-                const response = await this.content.get(contentId, params);
+            getByIdData: async (contentId, params) => {
+                const response = await this.content.getById(contentId, params);
                 return response.data;
             },
             /**
-             * 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: async (contentId) => {
-                const response = await this.content.getDoc(contentId);
-                return response.data;
+            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: async (contentId, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/content/{id}/doc',
+                        paramsSchema: schemas_1.ContentIdDocParamsSchema,
+                        responseSchema: schemas_1.ContentIdDocResponseSchema,
+                    }, params, { id: String(contentId) });
+                },
+                /**
+                 * 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: async (contentId, params) => {
+                    const response = await this.content.doc.get(contentId, params);
+                    return response.data;
+                },
             },
         };
         /**
-         * User endpoints
-         * @description Methods for user management including authentication, CRUD operations, and group management
+         * Health check endpoint - /health-check
          */
-        this.users = {
+        this.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: this.createListMethod('/users', schemas_2.BaseGetParamsSchema, schemas_1.GenericListResponseSchema),
-            /**
-             * Get user details by ID
-             * @description Returns detailed information for a specific user including profile data and metadata
-             * @fullPath api.joomla.users.get
-             * @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
-             * @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: async (userId) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/users/{id}',
-                    responseSchema: schemas_1.GenericResponseSchema,
-                }, undefined, { id: String(userId) });
-            },
-            /**
-             * 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: async (userId) => {
+            get: async () => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/users/{id}/doc',
-                    responseSchema: schemas_1.GenericResponseSchema,
-                }, undefined, { id: String(userId) });
+                    path: '/health-check',
+                    responseSchema: schemas_1.HealthCheckResponseSchema,
+                });
             },
             /**
-             * 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 });
-             * ```
+             * Get service health data only - /health-check GET (data method)
+             * @fullPath api.joomla.healthCheck.getData
+             * @service joomla
+             * @domain system
+             * @dataMethod getData() - returns only the health data without metadata
+             * @discoverable true
+             * @searchTerms ["health data", "service health data", "health check data"]
+             * @relatedEndpoints ["api.joomla.healthCheck.get"]
+             * @commonPatterns ["extract health data", "get health status only"]
              */
-            getTrinityDoc: async (userId, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/users/{id}/trinity',
-                    paramsSchema: schemas_2.BaseGetParamsSchema,
-                    responseSchema: schemas_1.GenericResponseSchema,
-                }, params, { id: String(userId) });
+            getData: async () => {
+                const response = await this.healthCheck.get();
+                return response.data;
             },
-            /**
-             * User groups sub-endpoints
-             * @description Methods for managing user group memberships and relationships
-             */
-            groups: {
+        };
+        /**
+         * Menu endpoints - /menu/{id}/doc
+         */
+        this.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: async (userId, params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: '/users/{id}/groups',
-                        paramsSchema: schemas_2.BaseGetParamsSchema,
-                        responseSchema: schemas_1.GenericResponseSchema,
-                    }, params, { id: userId });
-                },
-                /**
-                 * 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);
-                 * ```
+                 * @searchTerms ["menu document", "menu doc", "menu item document"]
+                 * @relatedEndpoints ["api.joomla.content.doc.get"]
+                 * @commonPatterns ["get menu document", "fetch menu item details"]
                  */
-                get: async (userId, groupId) => {
+                get: async (menuId) => {
                     return this.executeRequest({
                         method: 'GET',
-                        path: '/users/{id}/groups/{groupId}',
-                        responseSchema: schemas_1.GenericResponseSchema,
-                    }, undefined, { id: userId, groupId: String(groupId) });
+                        path: '/menu/{id}/doc',
+                        responseSchema: schemas_1.MenuIdDocResponseSchema,
+                    }, undefined, { id: menuId });
                 },
                 /**
-                 * 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');
-                 * ```
-                 */
-                createMapping: async (userId, request) => {
-                    return this.executeRequest({
-                        method: 'POST',
-                        path: '/users/{id}/groups',
-                        responseSchema: schemas_1.GenericResponseSchema,
-                    }, request, { id: String(userId) });
-                },
-                /**
-                 * 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: async (userId, params) => {
-                    const response = await this.users.groups.list(userId, params);
-                    return response.data;
-                },
-                /**
-                 * 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: async (userId, groupId) => {
-                    const response = await this.users.groups.get(userId, groupId);
-                    return response.data;
-                },
-                /**
-                 * 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: async (userId, request) => {
-                    const response = await this.users.groups.createMapping(userId, request);
+                getData: async (menuId) => {
+                    const response = await this.menu.doc.get(menuId);
                     return response.data;
                 },
             },
+        };
+        /**
+         * Tags endpoints - /tags
+         */
+        this.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: async (request) => {
+            get: async (params) => {
                 return this.executeRequest({
-                    method: 'POST',
-                    path: '/users/verify-password',
-                    paramsSchema: schemas_1.VerifyPasswordRequestSchema,
-                    responseSchema: schemas_1.VerifyPasswordResponseSchema,
-                }, request);
+                    method: 'GET',
+                    path: '/tags',
+                    paramsSchema: schemas_1.TagsParamsSchema,
+                    responseSchema: schemas_1.TagsResponseSchema,
+                }, params);
             },
             /**
-             * 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 user-management
-             * @dataMethod createData(request) - returns only the created user object without metadata
+             * @domain content-management
+             * @dataMethod getData() - returns only the tags 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);
-             * ```
-             */
-            create: this.createCreateMethod('/users', schemas_1.CreateUserRequestSchema, schemas_1.GenericResponseSchema),
-            /**
-             * 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);
-             * ```
+             * @searchTerms ["tags data", "content tags data", "get tags data only"]
+             * @relatedEndpoints ["api.joomla.tags.get"]
+             * @commonPatterns ["extract tags data", "get content tags data only"]
              */
-            update: this.createUpdateMethod('/users/{id}', schemas_1.UpdateUserRequestSchema, schemas_1.GenericResponseSchema),
+            getData: async (params) => {
+                const response = await this.tags.get(params);
+                return response.data;
+            },
+        };
+        /**
+         * Users endpoints - /users
+         */
+        this.users = {
             /**
-             * 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');
-             * }
-             * ```
+             * 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"]
              */
-            block: this.createDeleteMethod('/users/{id}', schemas_1.GenericResponseSchema),
+            get: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/users',
+                    paramsSchema: schemas_1.UsersParamsSchema,
+                    responseSchema: schemas_1.UsersResponseSchema,
+                }, params);
+            },
             /**
-             * 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
+             * Get users data only - /users GET (data method)
+             * @fullPath api.joomla.users.getData
+             * @service joomla
+             * @domain user-management
+             * @dataMethod getData() - returns only the users array without metadata
+             * @discoverable true
+             * @searchTerms ["users data", "get users data", "user list data"]
+             * @relatedEndpoints ["api.joomla.users.get"]
+             * @commonPatterns ["extract users data", "get user list data only"]
              */
-            listData: async (params) => {
-                const response = await this.users.list(params);
+            getData: async (params) => {
+                const response = await this.users.get(params);
                 return response.data;
             },
             /**
-             * 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
+             * 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"]
              */
-            getData: async (userId) => {
-                const response = await this.users.get(userId);
-                return response.data;
+            create: async (request) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/users',
+                    paramsSchema: schemas_1.UsersCreateRequestSchema,
+                    responseSchema: schemas_1.UsersCreateResponseSchema,
+                }, request);
             },
             /**
-             * 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
+             * 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"]
              */
-            getDocData: async (userId) => {
-                const response = await this.users.getDoc(userId);
+            createData: async (request) => {
+                const response = await this.users.create(request);
                 return response.data;
             },
             /**
-             * 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: async (userId, params) => {
-                const response = await this.users.getTrinityDoc(userId, params);
-                return response.data;
+            getById: async (userId) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/users/{id}',
+                    responseSchema: schemas_1.UsersIdResponseSchema,
+                }, undefined, { id: String(userId) });
             },
             /**
-             * 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: async (request) => {
-                const response = await this.users.verifyPassword(request);
+            getByIdData: async (userId) => {
+                const response = await this.users.getById(userId);
                 return response.data;
             },
             /**
-             * 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
+             * 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"]
              */
-            createData: async (request) => {
-                const response = await this.users.create(request);
-                return response.data;
+            update: async (userId, request) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/users/{id}',
+                    paramsSchema: schemas_1.UsersIdUpdateRequestSchema,
+                    responseSchema: schemas_1.UsersIdUpdateResponseSchema,
+                }, request, { id: String(userId) });
             },
             /**
-             * 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 data only - /users/{id} PUT (data method)
+             * @fullPath api.joomla.users.updateData
+             * @service joomla
+             * @domain user-management
+             * @dataMethod updateData() - returns only the updated user data without metadata
+             * @discoverable true
+             * @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"]
              */
             updateData: async (userId, request) => {
                 const response = await this.users.update(userId, request);
                 return response.data;
             },
             /**
-             * 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
+             * 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"]
              */
-            blockData: async (userId) => {
-                const response = await this.users.block(userId);
-                return response.data;
+            delete: async (userId) => {
+                return this.executeRequest({
+                    method: 'DELETE',
+                    path: '/users/{id}',
+                    responseSchema: schemas_1.UsersIdDeleteResponseSchema,
+                }, undefined, { id: String(userId) });
             },
-        };
-        /**
-         * User Groups endpoints
-         * @description Methods for managing system-wide user groups and their hierarchy
-         */
-        this.userGroups = {
             /**
-             * Get hierarchical list of user groups
-             * @description Returns system-wide user groups with hierarchy information, filtering, and caching
-             * @fullPath api.joomla.userGroups.list
+             * Delete user data only - /users/{id} DELETE (data method)
+             * @fullPath api.joomla.users.deleteData
              * @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 deleteData() - returns only the deletion result 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 ["delete user data", "remove user data", "user deletion data"]
+             * @relatedEndpoints ["api.joomla.users.delete"]
+             * @commonPatterns ["extract deletion result", "get deletion data only"]
              */
-            list: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/usergroups',
-                    paramsSchema: schemas_2.BaseGetParamsSchema,
-                    responseSchema: schemas_1.GenericResponseSchema,
-                }, params);
+            deleteData: async (userId) => {
+                const response = await this.users.delete(userId);
+                return response.data;
             },
             /**
-             * 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
+             * User document - /users/{id}/doc
              */
-            listData: async (params) => {
-                const response = await this.userGroups.list(params);
-                return response.data;
+            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: async (userId) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/users/{id}/doc',
+                        responseSchema: schemas_1.UsersIdDocResponseSchema,
+                    }, undefined, { id: String(userId) });
+                },
+                /**
+                 * 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: async (userId) => {
+                    const response = await this.users.doc.get(userId);
+                    return response.data;
+                },
             },
-        };
-        /**
-         * Tags endpoints
-         * @description Methods for managing content tags and their hierarchical relationships
-         */
-        this.tags = {
             /**
-             * Get hierarchical list of content tags
-             * @description Returns content tags with hierarchy, usage information, filtering, search, and edge caching
-             * @fullPath api.joomla.tags.list
-             * @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
-             * @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
-             * });
-             * ```
+             * Trinity user document - /users/{id}/trinity
              */
-            list: this.createListMethod('/tags', schemas_2.BaseGetParamsSchema, schemas_1.GenericListResponseSchema),
+            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: async (userId, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/users/{id}/trinity',
+                        paramsSchema: schemas_1.UsersIdTrinityParamsSchema,
+                        responseSchema: schemas_1.UsersIdTrinityResponseSchema,
+                    }, params, { id: String(userId) });
+                },
+                /**
+                 * 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: async (userId, params) => {
+                    const response = await this.users.trinity.get(userId, params);
+                    return response.data;
+                },
+            },
             /**
-             * 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 groups - /users/{id}/groups
              */
-            listData: async (params) => {
-                const response = await this.tags.list(params);
-                return response.data;
+            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: async (userId, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/users/{id}/groups',
+                        paramsSchema: schemas_1.UsersIdGroupsParamsSchema,
+                        responseSchema: schemas_1.UsersIdGroupsResponseSchema,
+                    }, params, { id: userId });
+                },
+                /**
+                 * 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: async (userId, params) => {
+                    const response = await this.users.groups.get(userId, params);
+                    return response.data;
+                },
+                /**
+                 * 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: async (userId, request) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/users/{id}/groups',
+                        paramsSchema: schemas_1.UsersIdGroupsCreateRequestSchema,
+                        responseSchema: schemas_1.UsersIdGroupsCreateResponseSchema,
+                    }, request, { id: String(userId) });
+                },
+                /**
+                 * 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: async (userId, request) => {
+                    const response = await this.users.groups.create(userId, request);
+                    return response.data;
+                },
+                /**
+                 * 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: async (userId, groupId) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/users/{id}/groups/{groupId}',
+                        responseSchema: schemas_1.UsersIdGroupsGroupIdResponseSchema,
+                    }, undefined, { id: userId, groupId: String(groupId) });
+                },
+                /**
+                 * 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: async (userId, groupId) => {
+                    const response = await this.users.groups.getById(userId, groupId);
+                    return response.data;
+                },
+            },
+            /**
+             * 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: async (request) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/users/verify-password',
+                        paramsSchema: schemas_1.UsersVerifyPasswordRequestSchema,
+                        responseSchema: schemas_1.UsersVerifyPasswordResponseSchema,
+                    }, request);
+                },
+                /**
+                 * 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: async (request) => {
+                    const response = await this.users.verifyPassword.create(request);
+                    return response.data;
+                },
             },
         };
         /**
-         * Menu endpoints
-         * @description Methods for accessing menu structure and navigation documentation
+         * User Groups endpoints - /usergroups
          */
-        this.menu = {
+        this.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: async (menuId) => {
+            get: async (params) => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/menu/{id}/doc',
-                    responseSchema: schemas_1.GenericResponseSchema,
-                }, undefined, { id: menuId });
+                    path: '/usergroups',
+                    paramsSchema: schemas_1.UserGroupsParamsSchema,
+                    responseSchema: schemas_1.UserGroupsResponseSchema,
+                }, params);
             },
             /**
-             * 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: async (menuId) => {
-                const response = await this.menu.getDoc(menuId);
+            getData: async (params) => {
+                const response = await this.userGroups.get(params);
                 return response.data;
             },
         };
         /**
-         * 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);
-         * ```
-         */
-        this.getHealthCheck = this.createHealthCheckMethod(schemas_1.HealthCheckResponseSchema);
-        /**
-         * 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)
          */
         this.ping = this.createPingMethod(schemas_1.PingResponseSchema);
         /**
          * Health Data Operations
-         * @description Direct access to health check data without response metadata
          */
         this.healthData = {
-            /**
-             * Get health check data without response metadata
-             * @returns Promise<unknown> Health status data directly
-             */
             check: async () => {
-                const response = await this.getHealthCheck();
+                const response = await this.healthCheck.get();
                 return response.data;
             },
-            /**
-             * Get ping data without response metadata
-             * @returns Promise<unknown> Ping response data directly
-             */
             ping: async () => {
                 const response = await this.ping();
                 return response.data;
             },
         };
     }
-    /**
-     * Override getDiscoveryMetadata to provide hardcoded endpoint metadata
-     * This works around the JSDoc parsing issue in compiled JavaScript
-     */
-    getDiscoveryMetadata() {
-        return {
-            serviceName: this.serviceName,
-            description: this.getServiceDescription(),
-            baseUrl: this.baseUrl,
-            endpoints: [
-                {
-                    fullPath: 'api.joomla.users.list',
-                    service: 'joomla',
-                    domain: 'user-management',
-                    method: 'GET',
-                    path: '/users',
-                    description: 'Retrieve a paginated list of users',
-                    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'],
-                    dataMethod: 'listData()',
-                    discoverable: true,
-                },
-                {
-                    fullPath: 'api.joomla.users.get',
-                    service: 'joomla',
-                    domain: 'user-management',
-                    method: 'GET',
-                    path: '/users/{id}',
-                    description: 'Get user details by ID',
-                    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'],
-                    dataMethod: 'getData(userId, params)',
-                    discoverable: true,
-                },
-                {
-                    fullPath: 'api.joomla.users.verifyPassword',
-                    service: 'joomla',
-                    domain: 'authentication',
-                    method: 'POST',
-                    path: '/users/verify-password',
-                    description: 'Verify user credentials and authenticate',
-                    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',
-                    ],
-                    dataMethod: 'verifyPasswordData(request)',
-                    discoverable: true,
-                },
-                {
-                    fullPath: 'api.joomla.users.create',
-                    service: 'joomla',
-                    domain: 'user-management',
-                    method: 'POST',
-                    path: '/users',
-                    description: 'Create a new user account',
-                    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',
-                    ],
-                    dataMethod: 'createData(request)',
-                    discoverable: true,
-                },
-                {
-                    fullPath: 'api.joomla.content.list',
-                    service: 'joomla',
-                    domain: 'content-management',
-                    method: 'GET',
-                    path: '/content',
-                    description: 'Retrieve a paginated list of content items',
-                    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',
-                    ],
-                    dataMethod: 'listData()',
-                    discoverable: true,
-                },
-                {
-                    fullPath: 'api.joomla.userGroups.list',
-                    service: 'joomla',
-                    domain: 'user-management',
-                    method: 'GET',
-                    path: '/usergroups',
-                    description: 'Get hierarchical list of user groups',
-                    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',
-                    ],
-                    dataMethod: 'listData(params)',
-                    discoverable: true,
-                },
-            ],
-        };
-    }
 }
 exports.JoomlaClient = JoomlaClient;
 //# sourceMappingURL=client.js.map