@simpleapps-com/augur-api 0.3.3 → 0.4.0

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

@@ -1,6 +1,6 @@
 import { BaseServiceClient } from '../../core/base-client';
 import type { HTTPClient } from '../../core/client';
-import { HealthCheckParams, HealthCheckResponse, WebHookRequestParams, WebHookResponse, WebHookRefreshParams, WebHookRefreshResponse, WebHookData, WebHookRefreshData } from './schemas';
+import { HealthCheckParams, HealthCheckResponse, HealthCheckData, WebHookCreateParams, WebHookResponse, WebHookData, WebHookRefreshParams, WebHookRefreshResponse, WebHookRefreshData } from './schemas';
 /**
  * Slack Integration Service Client
  *
@@ -15,271 +15,300 @@ export declare class SlackClient extends BaseServiceClient {
     constructor(http: HTTPClient, baseUrl?: string);
     protected getServiceDescription(): string;
     /**
-     * Check Slack service health and connectivity
-     *
-     * @fullPath api.slack.healthCheck.get
-     * @service slack
-     * @domain system-health
-     * @dataMethod healthCheckData
-     * @discoverable true
-     * @searchTerms ["health", "status", "availability", "ping", "check", "slack service", "webhook connectivity", "integration status"]
-     * @relatedEndpoints ["api.slack.webHook.send", "api.slack.webHook.refresh", "api.joomla.healthCheck.get", "api.commerce.healthCheck.get", "api.customers.healthCheck.get"]
-     * @commonPatterns ["Health check", "Service status", "Slack connectivity test", "System monitoring", "Integration verification"]
-     * @workflow ["system-monitoring", "health-checks", "service-discovery", "slack-integration-verification", "webhook-status-check"]
-     * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header", "Slack API connectivity"]
-     * @nextSteps ["Use webhook endpoints if healthy", "Verify Slack API connectivity", "Monitor integration metrics", "Test message delivery"]
-     * @businessRules ["Returns service and Slack connectivity status", "Requires standard authentication", "Standard health check format", "Includes webhook status"]
-     * @functionalArea "system-monitoring"
-     * @caching "No caching - real-time status required"
-     * @performance "Fast response, minimal processing, use for Slack integration monitoring"
-     *
-     * @param params Health check parameters with site ID
-     * @returns Promise<HealthCheckResponse> Service health status with Slack connectivity information
-     *
-     * @example
-     * ```typescript
-     * // Check if Slack service is healthy
-     * const response = await client.healthCheck({ 'x-site-id': 'SITE123' });
-     * console.log(response.data.status); // 'healthy'
-     * console.log(response.data.slack_connectivity); // true/false
-     * console.log(response.status); // HTTP status code
-     *
-     * // Get just the health status
-     * const status = await client.healthCheckData({ 'x-site-id': 'SITE123' });
-     * console.log(status); // Health data object
-     * ```
+     * Health check operations
+     * OpenAPI path: /health-check
      */
-    healthCheck(params: HealthCheckParams): Promise<HealthCheckResponse>;
+    get healthCheck(): {
+        /**
+         * Check Slack service health and connectivity
+         *
+         * @fullPath api.slack.healthCheck.get
+         * @service slack
+         * @domain system-health
+         * @dataMethod healthCheckData
+         * @discoverable true
+         * @searchTerms ["health", "status", "availability", "ping", "check", "slack service", "webhook connectivity", "integration status"]
+         * @relatedEndpoints ["api.slack.webHook.create", "api.slack.webHook.refresh.get", "api.joomla.healthCheck.get", "api.commerce.healthCheck.get", "api.customers.healthCheck.get"]
+         * @commonPatterns ["Health check", "Service status", "Slack connectivity test", "System monitoring", "Integration verification"]
+         * @workflow ["system-monitoring", "health-checks", "service-discovery", "slack-integration-verification", "webhook-status-check"]
+         * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header", "Slack API connectivity"]
+         * @nextSteps ["Use webhook endpoints if healthy", "Verify Slack API connectivity", "Monitor integration metrics", "Test message delivery"]
+         * @businessRules ["Returns service and Slack connectivity status", "Requires standard authentication", "Standard health check format", "Includes webhook status"]
+         * @functionalArea "system-monitoring"
+         * @caching "No caching - real-time status required"
+         * @performance "Fast response, minimal processing, use for Slack integration monitoring"
+         *
+         * @param params Health check parameters with site ID
+         * @returns Promise<HealthCheckResponse> Service health status with Slack connectivity information
+         *
+         * @example
+         * ```typescript
+         * // Check if Slack service is healthy
+         * const response = await client.healthCheck.get({ 'x-site-id': 'SITE123' });
+         * console.log(response.data.status); // 'healthy'
+         * console.log(response.data.slack_connectivity); // true/false
+         * console.log(response.status); // HTTP status code
+         *
+         * // Get just the health status
+         * const status = await client.healthCheckData.get({ 'x-site-id': 'SITE123' });
+         * console.log(status); // Health data object
+         * ```
+         */
+        get: (params: HealthCheckParams) => Promise<HealthCheckResponse>;
+    };
     /**
-     * Send messages and manage Slack webhooks
-     *
-     * @fullPath api.slack.webHook.send
-     * @service slack
-     * @domain communication-and-notifications
-     * @dataMethod webHookData
-     * @discoverable true
-     * @searchTerms ["slack", "webhook", "message", "notification", "send", "channel", "team communication", "alerts", "blocks", "attachments"]
-     * @relatedEndpoints ["api.slack.webHook.refresh", "api.joomla.users.notifications", "api.commerce.orders.notifications", "api.customers.alerts.create"]
-     * @commonPatterns ["Send Slack message", "Team notification", "Alert delivery", "Webhook integration", "Channel broadcast", "User notification"]
-     * @workflow ["notification-delivery", "team-communication", "alert-management", "webhook-integration", "message-broadcasting", "incident-response"]
-     * @prerequisites ["Valid Slack webhook URL", "Channel permissions", "Valid authentication token", "x-site-id header", "Message content"]
-     * @nextSteps ["Monitor delivery status", "Handle webhook responses", "Update notification preferences", "Track message engagement"]
-     * @businessRules ["Supports Slack Block Kit and legacy attachments", "Requires webhook URL or channel", "Message formatting follows Slack standards", "Delivery status tracking", "Retry logic for failed deliveries"]
-     * @functionalArea "communication-and-notifications"
-     * @crossSite "Multi-site webhook configuration and message routing"
-     * @caching "No caching - real-time message delivery required"
-     * @performance "Async delivery with status tracking, batch messages for high volume, use blocks for rich formatting"
-     *
-     * @param params Webhook request parameters including message content, formatting, and delivery options
-     * @returns Promise<WebHookResponse> Webhook delivery status and message metadata
-     *
-     * @example
-     * ```typescript
-     * // Send simple text message
-     * const simpleMessage = {
-     *   text: "Hello from the API!",
-     *   channel: "#general",
-     *   'x-site-id': 'SITE123'
-     * };
-     * const response = await client.webHook(simpleMessage);
-     * console.log(response.data.delivery_status); // 'sent', 'delivered', 'failed'
-     *
-     * // Send rich message with blocks (modern Slack formatting)
-     * const richMessage = {
-     *   channel: "#alerts",
-     *   blocks: [{
-     *     type: "section",
-     *     text: {
-     *       type: "mrkdwn",
-     *       text: "*Order Alert* :warning:\nNew high-value order received"
-     *     }
-     *   }, {
-     *     type: "section",
-     *     fields: [{
-     *       type: "mrkdwn",
-     *       text: "*Order ID:*\n#12345"
-     *     }, {
-     *       type: "mrkdwn",
-     *       text: "*Amount:*\n$1,250.00"
-     *     }]
-     *   }],
-     *   'x-site-id': 'SITE123'
-     * };
-     * const alertResponse = await client.webHook(richMessage);
-     *
-     * // Send message with legacy attachments
-     * const attachmentMessage = {
-     *   text: "Order Processing Update",
-     *   channel: "#orders",
-     *   attachments: [{
-     *     color: "good",
-     *     title: "Order #12345 Processed",
-     *     text: "Customer order has been successfully processed and shipped.",
-     *     fields: [{
-     *       title: "Customer",
-     *       value: "John Doe",
-     *       short: true
-     *     }, {
-     *       title: "Total",
-     *       value: "$299.99",
-     *       short: true
-     *     }],
-     *     footer: "Order System",
-     *     ts: Date.now() / 1000
-     *   }],
-     *   'x-site-id': 'SITE123'
-     * };
-     * const orderUpdate = await client.webHook(attachmentMessage);
-     *
-     * // Get just the webhook data
-     * const deliveryStatus = await client.webHookData(simpleMessage);
-     * console.log(deliveryStatus); // Direct webhook data access
-     *
-     * // Configure webhook for automated notifications
-     * const webhookConfig = {
-     *   url: "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
-     *   channel: "#automation",
-     *   username: "API Bot",
-     *   icon_emoji: ":robot_face:",
-     *   webhook_type: "incoming",
-     *   'x-site-id': 'SITE123'
-     * };
-     * const configResponse = await client.webHook(webhookConfig);
-     * ```
+     * Health check data operations
+     * OpenAPI path: /health-check (data only)
      */
-    webHook(params: WebHookRequestParams): Promise<WebHookResponse>;
+    get healthCheckData(): {
+        /**
+         * Get Slack service health data without full response metadata
+         *
+         * @fullPath api.slack.healthCheckData.get
+         * @service slack
+         * @domain system-health
+         * @dataMethod healthCheckData
+         * @discoverable true
+         * @searchTerms ["health data", "service status", "slack connectivity", "integration status"]
+         * @relatedEndpoints ["api.slack.healthCheck.get", "api.slack.webHook.create"]
+         * @commonPatterns ["Get health status", "Check connectivity", "Service monitoring"]
+         * @workflow ["system-monitoring", "health-checks", "integration-verification"]
+         * @prerequisites ["Valid authentication token", "x-site-id header"]
+         * @nextSteps ["Use Slack endpoints if healthy", "Monitor service metrics"]
+         * @businessRules ["Returns only health data object", "No response metadata included"]
+         * @functionalArea "system-monitoring"
+         * @caching "No caching - real-time status required"
+         * @performance "Direct data access, faster for simple health checks"
+         *
+         * @param params Health check parameters with site ID
+         * @returns Promise<HealthCheckData> Direct health status data object
+         */
+        get: (params: HealthCheckParams) => Promise<HealthCheckData>;
+    };
     /**
-     * Refresh Slack webhook configurations and connectivity
-     *
-     * @fullPath api.slack.webHook.refresh
-     * @service slack
-     * @domain communication-and-notifications
-     * @dataMethod webHookRefreshData
-     * @discoverable true
-     * @searchTerms ["webhook", "refresh", "configuration", "update", "sync", "connectivity", "channels", "integration refresh"]
-     * @relatedEndpoints ["api.slack.webHook.send", "api.slack.healthCheck.get", "api.joomla.configuration.refresh", "api.commerce.settings.sync"]
-     * @commonPatterns ["Refresh webhook config", "Update integration", "Sync channels", "Reconnect webhooks", "Configuration update"]
-     * @workflow ["webhook-management", "integration-maintenance", "configuration-sync", "connectivity-restoration", "channel-discovery"]
-     * @prerequisites ["Valid authentication token", "x-site-id header", "Webhook configurations exist", "Slack API connectivity"]
-     * @nextSteps ["Verify refreshed configurations", "Test webhook delivery", "Update channel mappings", "Monitor integration health"]
-     * @businessRules ["Refreshes all webhook configurations", "Discovers new channels", "Validates existing webhooks", "Updates connectivity status", "Handles configuration errors"]
-     * @functionalArea "communication-and-notifications"
-     * @crossSite "Multi-site webhook configuration refresh"
-     * @caching "Cache refreshed configuration for 1 hour"
-     * @performance "May take several seconds for full refresh, run periodically to maintain connectivity"
-     *
-     * @param params Webhook refresh parameters including force refresh option
-     * @returns Promise<WebHookRefreshResponse> Refresh results with configuration status and channel information
-     *
-     * @example
-     * ```typescript
-     * // Standard webhook refresh
-     * const refreshResponse = await client.webHookRefresh({ 'x-site-id': 'SITE123' });
-     * console.log(refreshResponse.data.refreshed); // true/false
-     * console.log(refreshResponse.data.active_webhooks); // Count of active webhooks
-     * console.log(refreshResponse.data.channels); // Available channels
-     *
-     * // Force refresh (bypasses cache)
-     * const forceRefresh = await client.webHookRefresh({
-     *   'x-site-id': 'SITE123',
-     *   force: true
-     * });
-     * console.log(forceRefresh.data.configuration_status); // 'valid', 'invalid', 'partial'
-     *
-     * // Get just the refresh data
-     * const refreshData = await client.webHookRefreshData({ 'x-site-id': 'SITE123' });
-     * console.log(refreshData); // Direct refresh data access
-     *
-     * // Handle refresh errors
-     * const refreshResult = await client.webHookRefresh({ 'x-site-id': 'SITE123' });
-     * if (refreshResult.data.errors && refreshResult.data.errors.length > 0) {
-     *   console.log('Refresh errors:', refreshResult.data.errors);
-     *   // Handle configuration issues
-     * }
-     *
-     * // Monitor webhook health after refresh
-     * if (refreshResult.data.inactive_webhooks > 0) {
-     *   console.log(`${refreshResult.data.inactive_webhooks} webhooks need attention`);
-     *   // Investigate inactive webhooks
-     * }
-     * ```
+     * WebHook operations
+     * OpenAPI path: /web-hook
      */
-    webHookRefresh(params: WebHookRefreshParams): Promise<WebHookRefreshResponse>;
+    get webHook(): {
+        /**
+         * Send messages and manage Slack webhooks
+         *
+         * @fullPath api.slack.webHook.create
+         * @service slack
+         * @domain communication-and-notifications
+         * @dataMethod webHookData.create
+         * @discoverable true
+         * @searchTerms ["slack", "webhook", "message", "notification", "send", "channel", "team communication", "alerts", "blocks", "attachments"]
+         * @relatedEndpoints ["api.slack.webHook.refresh.get", "api.joomla.users.notifications", "api.commerce.orders.notifications", "api.customers.alerts.create"]
+         * @commonPatterns ["Send Slack message", "Team notification", "Alert delivery", "Webhook integration", "Channel broadcast", "User notification"]
+         * @workflow ["notification-delivery", "team-communication", "alert-management", "webhook-integration", "message-broadcasting", "incident-response"]
+         * @prerequisites ["Valid Slack webhook URL", "Channel permissions", "Valid authentication token", "x-site-id header", "Message content"]
+         * @nextSteps ["Monitor delivery status", "Handle webhook responses", "Update notification preferences", "Track message engagement"]
+         * @businessRules ["Supports Slack Block Kit and legacy attachments", "Requires webhook URL or channel", "Message formatting follows Slack standards", "Delivery status tracking", "Retry logic for failed deliveries"]
+         * @functionalArea "communication-and-notifications"
+         * @crossSite "Multi-site webhook configuration and message routing"
+         * @caching "No caching - real-time message delivery required"
+         * @performance "Async delivery with status tracking, batch messages for high volume, use blocks for rich formatting"
+         *
+         * @param params Webhook request parameters including message content, formatting, and delivery options
+         * @returns Promise<WebHookResponse> Webhook delivery status and message metadata
+         *
+         * @example
+         * ```typescript
+         * // Send simple text message
+         * const simpleMessage = {
+         *   text: "Hello from the API!",
+         *   channel: "#general",
+         *   'x-site-id': 'SITE123'
+         * };
+         * const response = await client.webHook.create(simpleMessage);
+         * console.log(response.data.delivery_status); // 'sent', 'delivered', 'failed'
+         *
+         * // Send rich message with blocks (modern Slack formatting)
+         * const richMessage = {
+         *   channel: "#alerts",
+         *   blocks: [{
+         *     type: "section",
+         *     text: {
+         *       type: "mrkdwn",
+         *       text: "*Order Alert* :warning:\nNew high-value order received"
+         *     }
+         *   }, {
+         *     type: "section",
+         *     fields: [{
+         *       type: "mrkdwn",
+         *       text: "*Order ID:*\n#12345"
+         *     }, {
+         *       type: "mrkdwn",
+         *       text: "*Amount:*\n$1,250.00"
+         *     }]
+         *   }],
+         *   'x-site-id': 'SITE123'
+         * };
+         * const alertResponse = await client.webHook.create(richMessage);
+         *
+         * // Send message with legacy attachments
+         * const attachmentMessage = {
+         *   text: "Order Processing Update",
+         *   channel: "#orders",
+         *   attachments: [{
+         *     color: "good",
+         *     title: "Order #12345 Processed",
+         *     text: "Customer order has been successfully processed and shipped.",
+         *     fields: [{
+         *       title: "Customer",
+         *       value: "John Doe",
+         *       short: true
+         *     }, {
+         *       title: "Total",
+         *       value: "$299.99",
+         *       short: true
+         *     }],
+         *     footer: "Order System",
+         *     ts: Date.now() / 1000
+         *   }],
+         *   'x-site-id': 'SITE123'
+         * };
+         * const orderUpdate = await client.webHook.create(attachmentMessage);
+         *
+         * // Get just the webhook data
+         * const deliveryStatus = await client.webHookData.create(simpleMessage);
+         * console.log(deliveryStatus); // Direct webhook data access
+         *
+         * // Configure webhook for automated notifications
+         * const webhookConfig = {
+         *   url: "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
+         *   channel: "#automation",
+         *   username: "API Bot",
+         *   icon_emoji: ":robot_face:",
+         *   webhook_type: "incoming",
+         *   'x-site-id': 'SITE123'
+         * };
+         * const configResponse = await client.webHook.create(webhookConfig);
+         * ```
+         */
+        create: (params: WebHookCreateParams) => Promise<WebHookResponse>;
+        /**
+         * WebHook refresh operations
+         * OpenAPI path: /web-hook/refresh
+         */
+        refresh: {
+            /**
+             * Refresh Slack webhook configurations and connectivity
+             *
+             * @fullPath api.slack.webHook.refresh.get
+             * @service slack
+             * @domain communication-and-notifications
+             * @dataMethod webHookData.refresh.get
+             * @discoverable true
+             * @searchTerms ["webhook", "refresh", "configuration", "update", "sync", "connectivity", "channels", "integration refresh"]
+             * @relatedEndpoints ["api.slack.webHook.create", "api.slack.healthCheck.get", "api.joomla.configuration.refresh", "api.commerce.settings.sync"]
+             * @commonPatterns ["Refresh webhook config", "Update integration", "Sync channels", "Reconnect webhooks", "Configuration update"]
+             * @workflow ["webhook-management", "integration-maintenance", "configuration-sync", "connectivity-restoration", "channel-discovery"]
+             * @prerequisites ["Valid authentication token", "x-site-id header", "Webhook configurations exist", "Slack API connectivity"]
+             * @nextSteps ["Verify refreshed configurations", "Test webhook delivery", "Update channel mappings", "Monitor integration health"]
+             * @businessRules ["Refreshes all webhook configurations", "Discovers new channels", "Validates existing webhooks", "Updates connectivity status", "Handles configuration errors"]
+             * @functionalArea "communication-and-notifications"
+             * @crossSite "Multi-site webhook configuration refresh"
+             * @caching "Cache refreshed configuration for 1 hour"
+             * @performance "May take several seconds for full refresh, run periodically to maintain connectivity"
+             *
+             * @param params Webhook refresh parameters including force refresh option
+             * @returns Promise<WebHookRefreshResponse> Refresh results with configuration status and channel information
+             *
+             * @example
+             * ```typescript
+             * // Standard webhook refresh
+             * const refreshResponse = await client.webHook.refresh.get({ 'x-site-id': 'SITE123' });
+             * console.log(refreshResponse.data.refreshed); // true/false
+             * console.log(refreshResponse.data.active_webhooks); // Count of active webhooks
+             * console.log(refreshResponse.data.channels); // Available channels
+             *
+             * // Force refresh (bypasses cache)
+             * const forceRefresh = await client.webHook.refresh.get({
+             *   'x-site-id': 'SITE123',
+             *   force: true
+             * });
+             * console.log(forceRefresh.data.configuration_status); // 'valid', 'invalid', 'partial'
+             *
+             * // Get just the refresh data
+             * const refreshData = await client.webHookData.refresh.get({ 'x-site-id': 'SITE123' });
+             * console.log(refreshData); // Direct refresh data access
+             *
+             * // Handle refresh errors
+             * const refreshResult = await client.webHook.refresh.get({ 'x-site-id': 'SITE123' });
+             * if (refreshResult.data.errors && refreshResult.data.errors.length > 0) {
+             *   console.log('Refresh errors:', refreshResult.data.errors);
+             *   // Handle configuration issues
+             * }
+             *
+             * // Monitor webhook health after refresh
+             * if (refreshResult.data.inactive_webhooks > 0) {
+             *   console.log(`${refreshResult.data.inactive_webhooks} webhooks need attention`);
+             *   // Investigate inactive webhooks
+             * }
+             * ```
+             */
+            get: (params: WebHookRefreshParams) => Promise<WebHookRefreshResponse>;
+        };
+    };
     /**
-     * Get Slack service health data without full response metadata
-     *
-     * @fullPath api.slack.healthCheckData.get
-     * @service slack
-     * @domain system-health
-     * @dataMethod healthCheckData
-     * @discoverable true
-     * @searchTerms ["health data", "service status", "slack connectivity", "integration status"]
-     * @relatedEndpoints ["api.slack.healthCheck.get", "api.slack.webHook.send"]
-     * @commonPatterns ["Get health status", "Check connectivity", "Service monitoring"]
-     * @workflow ["system-monitoring", "health-checks", "integration-verification"]
-     * @prerequisites ["Valid authentication token", "x-site-id header"]
-     * @nextSteps ["Use Slack endpoints if healthy", "Monitor service metrics"]
-     * @businessRules ["Returns only health data object", "No response metadata included"]
-     * @functionalArea "system-monitoring"
-     * @caching "No caching - real-time status required"
-     * @performance "Direct data access, faster for simple health checks"
-     *
-     * @param params Health check parameters with site ID
-     * @returns Promise<HealthCheckData> Direct health status data object
+     * WebHook data operations
+     * OpenAPI path: /web-hook (data only)
      */
-    healthCheckData(params: HealthCheckParams): Promise<{
-        status: string;
-        service: string;
-        timestamp?: string | undefined;
-        version?: string | undefined;
-        slack_connectivity?: boolean | undefined;
-        webhook_status?: string | undefined;
-    }>;
-    /**
-     * Send Slack webhook and get data without full response metadata
-     *
-     * @fullPath api.slack.webHookData.send
-     * @service slack
-     * @domain communication-and-notifications
-     * @dataMethod webHookData
-     * @discoverable true
-     * @searchTerms ["webhook data", "message data", "delivery status", "notification result"]
-     * @relatedEndpoints ["api.slack.webHook.send", "api.slack.webHook.refresh"]
-     * @commonPatterns ["Send message data", "Get delivery status", "Direct webhook access"]
-     * @workflow ["notification-delivery", "team-communication", "alert-management"]
-     * @prerequisites ["Valid webhook configuration", "Message content", "Valid authentication token"]
-     * @nextSteps ["Monitor delivery status", "Handle webhook responses", "Track message engagement"]
-     * @businessRules ["Returns only webhook data", "No response metadata included", "Direct access to delivery status"]
-     * @functionalArea "communication-and-notifications"
-     * @caching "No caching - real-time delivery tracking"
-     * @performance "Direct data access, optimal for webhook status monitoring"
-     *
-     * @param params Webhook request parameters
-     * @returns Promise<WebHookData> Direct webhook delivery data without response wrapper
-     */
-    webHookData(params: WebHookRequestParams): Promise<WebHookData>;
-    /**
-     * Refresh webhooks and get data without full response metadata
-     *
-     * @fullPath api.slack.webHookRefreshData.get
-     * @service slack
-     * @domain communication-and-notifications
-     * @dataMethod webHookRefreshData
-     * @discoverable true
-     * @searchTerms ["refresh data", "webhook config", "integration status", "channel data"]
-     * @relatedEndpoints ["api.slack.webHookRefresh.get", "api.slack.webHook.send"]
-     * @commonPatterns ["Get refresh data", "Configuration status", "Channel information"]
-     * @workflow ["webhook-management", "integration-maintenance", "configuration-sync"]
-     * @prerequisites ["Valid authentication token", "x-site-id header", "Webhook configurations"]
-     * @nextSteps ["Verify configurations", "Test webhook delivery", "Update channel mappings"]
-     * @businessRules ["Returns only refresh data", "No response metadata included", "Direct access to configuration status"]
-     * @functionalArea "communication-and-notifications"
-     * @caching "Cache for 1 hour after refresh"
-     * @performance "Direct data access, optimal for configuration monitoring"
-     *
-     * @param params Webhook refresh parameters
-     * @returns Promise<WebHookRefreshData> Direct refresh data without response wrapper
-     */
-    webHookRefreshData(params: WebHookRefreshParams): Promise<WebHookRefreshData>;
+    get webHookData(): {
+        /**
+         * Send Slack webhook and get data without full response metadata
+         *
+         * @fullPath api.slack.webHookData.create
+         * @service slack
+         * @domain communication-and-notifications
+         * @dataMethod webHookData
+         * @discoverable true
+         * @searchTerms ["webhook data", "message data", "delivery status", "notification result"]
+         * @relatedEndpoints ["api.slack.webHook.create", "api.slack.webHook.refresh.get"]
+         * @commonPatterns ["Send message data", "Get delivery status", "Direct webhook access"]
+         * @workflow ["notification-delivery", "team-communication", "alert-management"]
+         * @prerequisites ["Valid webhook configuration", "Message content", "Valid authentication token"]
+         * @nextSteps ["Monitor delivery status", "Handle webhook responses", "Track message engagement"]
+         * @businessRules ["Returns only webhook data", "No response metadata included", "Direct access to delivery status"]
+         * @functionalArea "communication-and-notifications"
+         * @caching "No caching - real-time delivery tracking"
+         * @performance "Direct data access, optimal for webhook status monitoring"
+         *
+         * @param params Webhook request parameters
+         * @returns Promise<WebHookData> Direct webhook delivery data without response wrapper
+         */
+        create: (params: WebHookCreateParams) => Promise<WebHookData>;
+        /**
+         * WebHook refresh data operations
+         * OpenAPI path: /web-hook/refresh (data only)
+         */
+        refresh: {
+            /**
+             * Refresh webhooks and get data without full response metadata
+             *
+             * @fullPath api.slack.webHookData.refresh.get
+             * @service slack
+             * @domain communication-and-notifications
+             * @dataMethod webHookRefreshData
+             * @discoverable true
+             * @searchTerms ["refresh data", "webhook config", "integration status", "channel data"]
+             * @relatedEndpoints ["api.slack.webHook.refresh.get", "api.slack.webHook.create"]
+             * @commonPatterns ["Get refresh data", "Configuration status", "Channel information"]
+             * @workflow ["webhook-management", "integration-maintenance", "configuration-sync"]
+             * @prerequisites ["Valid authentication token", "x-site-id header", "Webhook configurations"]
+             * @nextSteps ["Verify configurations", "Test webhook delivery", "Update channel mappings"]
+             * @businessRules ["Returns only refresh data", "No response metadata included", "Direct access to configuration status"]
+             * @functionalArea "communication-and-notifications"
+             * @caching "Cache for 1 hour after refresh"
+             * @performance "Direct data access, optimal for configuration monitoring"
+             *
+             * @param params Webhook refresh parameters
+             * @returns Promise<WebHookRefreshData> Direct refresh data without response wrapper
+             */
+            get: (params: WebHookRefreshParams) => Promise<WebHookRefreshData>;
+        };
+    };
 }
 //# sourceMappingURL=client.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/services/slack/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAEL,iBAAiB,EAEjB,mBAAmB,EAEnB,oBAAoB,EAEpB,eAAe,EAEf,oBAAoB,EAEpB,sBAAsB,EACtB,WAAW,EACX,kBAAkB,EACnB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;GASG;AACH,qBAAa,WAAY,SAAQ,iBAAiB;gBACpC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,MAAM;IAI9C,SAAS,CAAC,qBAAqB,IAAI,MAAM;IAIzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACG,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAY1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgGG;IACG,OAAO,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,eAAe,CAAC;IAYrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuDG;IACG,cAAc,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAcnF;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,eAAe,CAAC,MAAM,EAAE,iBAAiB;;;;;;;;IAK/C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,WAAW,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,WAAW,CAAC;IAKrE;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,kBAAkB,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAIpF"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/services/slack/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAEL,iBAAiB,EAEjB,mBAAmB,EACnB,eAAe,EAEf,mBAAmB,EAEnB,eAAe,EACf,WAAW,EAEX,oBAAoB,EAEpB,sBAAsB,EACtB,kBAAkB,EACnB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;GASG;AACH,qBAAa,WAAY,SAAQ,iBAAiB;gBACpC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,MAAM;IAI9C,SAAS,CAAC,qBAAqB,IAAI,MAAM;IAIzC;;;OAGG;IACH,IAAI,WAAW;QAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAkCG;sBACiB,iBAAiB,KAAG,OAAO,CAAC,mBAAmB,CAAC;MAYvE;IAED;;;OAGG;IACH,IAAI,eAAe;QAEf;;;;;;;;;;;;;;;;;;;;;WAqBG;sBACiB,iBAAiB,KAAG,OAAO,CAAC,eAAe,CAAC;MAKnE;IAED;;;OAGG;IACH,IAAI,OAAO;QAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgGG;yBACoB,mBAAmB,KAAG,OAAO,CAAC,eAAe,CAAC;QAYrE;;;WAGG;;YAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAuDG;0BACiB,oBAAoB,KAAG,OAAO,CAAC,sBAAsB,CAAC;;MAa/E;IAED;;;OAGG;IACH,IAAI,WAAW;QAEX;;;;;;;;;;;;;;;;;;;;;WAqBG;yBACoB,mBAAmB,KAAG,OAAO,CAAC,WAAW,CAAC;QAKjE;;;WAGG;;YAED;;;;;;;;;;;;;;;;;;;;;eAqBG;0BACiB,oBAAoB,KAAG,OAAO,CAAC,kBAAkB,CAAC;;MAM3E;CACF"}

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

@@ -1,4 +1,4 @@
 export { SlackClient } from './client';
-export type { HealthCheckParams, WebHookRequestParams, WebHookRefreshParams, HealthCheckData, WebHookData, WebHookRefreshData, HealthCheckResponse, WebHookResponse, WebHookRefreshResponse, } from './schemas';
-export { HealthCheckParamsSchema, WebHookRequestParamsSchema, WebHookRefreshParamsSchema, HealthCheckDataSchema, WebHookDataSchema, WebHookRefreshDataSchema, HealthCheckResponseSchema, WebHookResponseSchema, WebHookRefreshResponseSchema, } from './schemas';
+export type { HealthCheckParams, HealthCheckData, HealthCheckResponse, WebHookCreateParams, WebHookData, WebHookResponse, WebHookRefreshParams, WebHookRefreshData, WebHookRefreshResponse, } from './schemas';
+export { HealthCheckParamsSchema, HealthCheckDataSchema, HealthCheckResponseSchema, WebHookCreateParamsSchema, WebHookDataSchema, WebHookResponseSchema, WebHookRefreshParamsSchema, WebHookRefreshDataSchema, WebHookRefreshResponseSchema, } from './schemas';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/slack/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGvC,YAAY,EACV,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EACf,WAAW,EACX,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,sBAAsB,GACvB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,uBAAuB,EACvB,0BAA0B,EAC1B,0BAA0B,EAC1B,qBAAqB,EACrB,iBAAiB,EACjB,wBAAwB,EACxB,yBAAyB,EACzB,qBAAqB,EACrB,4BAA4B,GAC7B,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/slack/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGvC,YAAY,EACV,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,WAAW,EACX,eAAe,EACf,oBAAoB,EACpB,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACrB,yBAAyB,EACzB,yBAAyB,EACzB,iBAAiB,EACjB,qBAAqB,EACrB,0BAA0B,EAC1B,wBAAwB,EACxB,4BAA4B,GAC7B,MAAM,WAAW,CAAC"}