import { ITGlueClient } from '../client';
import { QueryUtilOptions, QueryParams, RequestBody, BaseListResponse, BaseItemResponse, ConfigurationStatusResource } from '../types';
/**
 * ConfigurationStatuses resource module for IT Glue API
 *
 * Provides methods to interact with the /configuration_statuses endpoint.
 * Configuration statuses define the operational state of configurations, such as "Active",
 * "Inactive", "Maintenance", "Decommissioned", etc. These statuses help track the lifecycle
 * and current state of IT assets and infrastructure components.
 *
 * ## Related Resources
 * Configuration statuses are commonly used with:
 * - {@link Configurations} - IT assets that are assigned configuration statuses
 * - {@link ConfigurationTypes} - Types of configurations that use these statuses
 * - {@link ConfigurationInterfaces} - Network interfaces that inherit configuration statuses
 * - {@link Organizations} - Organizations that own configurations with these statuses
 * - {@link FlexibleAssets} - Custom assets that may reference configuration statuses
 * - {@link Documents} - Documentation related to status change procedures
 * - {@link RelatedItems} - Create relationships between statuses and other resources
 * - {@link Tags} - Categorize statuses by purpose or operational stage
 * - {@link Manufacturers} - Hardware manufacturers whose products use these statuses
 * - {@link Models} - Equipment models that are assigned these operational statuses
 *
 * @see {@link Configurations#list} for retrieving configurations by status
 * @see {@link ConfigurationTypes#list} for retrieving available configuration types
 * @see {@link ConfigurationInterfaces#list} for managing configuration interfaces
 * @see {@link Organizations#list} for retrieving organizations with configuration statuses
 *
 * @example
 * import { ITGlueClient } from '../client';
 * import { ConfigurationStatuses } from './resources/configuration-statuses';
 *
 * const client = new ITGlueClient({ apiKey: 'your-api-key' });
 * const configStatuses = new ConfigurationStatuses(client);
 *
 * // List configuration statuses
 * const list = await configStatuses.list();
 *
 * // Get a single configuration status
 * const status = await configStatuses.get('123');
 *
 * // Create a configuration status
 * const created = await configStatuses.create({
 *   data: {
 *     type: 'configuration_statuses',
 *     attributes: { name: 'Under Maintenance' }
 *   }
 * });
 *
 * // Update a configuration status
 * const updated = await configStatuses.update('123', {
 *   data: {
 *     type: 'configuration_statuses',
 *     attributes: { name: 'Decommissioned' }
 *   }
 * });
 *
 * // Delete a configuration status
 * await configStatuses.delete('123');
 *
 * @category Configurations
 */
export declare class ConfigurationStatuses {
    private client;
    private basePath;
    private paginationUtil;
    /**
     * Create a ConfigurationStatuses resource instance
     * @param {ITGlueClient} client - ITGlueClient instance
     */
    constructor(client: ITGlueClient);
    /**
     * List all configuration statuses
     * @param {QueryUtilOptions} [options] - Optional query parameters (filter, sort, page, etc.)
     * @param {boolean} [allPages=false] - If true, fetches all pages automatically
     * @returns {Promise<BaseListResponse<ConfigurationStatusResource>>} List of configuration statuses and pagination metadata
     * @example
     * // Basic usage - get first page of configuration statuses
     * const results = await client.configurationStatuses.list();
     * console.log(`Found ${results.data.length} configuration statuses`);
     * console.log('Total pages:', results.meta.pagination.total_pages);
     *
     * @example
     * // Advanced usage with pagination and sorting
     * const results = await client.configurationStatuses.list({
     *   page: { number: 2, size: 50 },
     *   sort: '-updated_at', // Sort by most recently updated
     *   include: ['configurations'] // Include related configurations
     * });
     *
     * @example
     * // Filtering results by status category
     * const filtered = await client.configurationStatuses.list({
     *   filter: {
     *     name: 'Active'
     *   },
     *   sort: 'name'
     * });
     *
     * console.log('Active statuses found:');
     * filtered.data.forEach(status => {
     *   console.log(`- ${status.attributes.name}: ${status.attributes.description || 'No description'}`);
     * });
     *
     * @example
     * // Get all results across multiple pages with lifecycle grouping
     * const allResults = await client.configurationStatuses.list({}, true); // allPages = true
     *
     * // Group by lifecycle stage for asset management
     * const lifecycleStages = {};
     * allResults.data.forEach(status => {
     *   const stage = status.attributes.name.toLowerCase().includes('active') ? 'Active' :
     *                status.attributes.name.toLowerCase().includes('maintenance') ? 'Maintenance' :
     *                status.attributes.name.toLowerCase().includes('decommission') ? 'End of Life' : 'Other';
     *
     *   if (!lifecycleStages[stage]) lifecycleStages[stage] = [];
     *   lifecycleStages[stage].push(status);
     * });
     *
     * console.log('Configuration statuses by lifecycle stage:', lifecycleStages);
     *
     * @example
     * // Manual pagination handling for large datasets
     * async function getAllConfigurationStatuses() {
     *   let page = 1;
     *   let allResults = [];
     *   let hasMore = true;
     *
     *   while (hasMore) {
     *     const response = await client.configurationStatuses.list({
     *       page: { number: page, size: 100 }
     *     });
     *
     *     allResults = [...allResults, ...response.data];
     *     hasMore = response.meta.pagination.total_pages > page;
     *     page++;
     *   }
     *
     *   return allResults;
     * }
     *
     * @example
     * // Error handling for list operations
     * try {
     *   const results = await client.configurationStatuses.list({
     *     filter: { invalid_field: 'value' }
     *   });
     * } catch (error) {
     *   if (error.response?.status === 400) {
     *     console.log('Invalid filter parameters:', error.response.data.errors);
     *   } else if (error.response?.status === 401) {
     *     console.log('Authentication failed - check your API key');
     *   } else if (error.response?.status === 403) {
     *     console.log('Access denied - insufficient permissions');
     *   } else {
     *     console.log('Request failed:', error.message);
     *   }
     * }
     */
    list(options?: QueryUtilOptions, allPages?: boolean): Promise<BaseListResponse<ConfigurationStatusResource>>;
    /**
     * Get a single configuration status by ID
     * @param {string} id - Configuration status ID
     * @param {QueryParams} [params] - Optional query parameters
     * @returns {Promise<BaseItemResponse<ConfigurationStatusResource>>} Configuration status resource
     * @example
     * // Basic usage - get configuration status by ID
     * const configStatus = await client.configurationStatuses.get('123');
     * console.log('Status name:', configStatus.data.attributes.name);
     * console.log('Description:', configStatus.data.attributes.description);
     * console.log('Color:', configStatus.data.attributes.color);
     *
     * @example
     * // Get configuration status with related configurations
     * const configStatusWithConfigs = await client.configurationStatuses.get('123', {
     *   include: ['configurations']
     * });
     *
     * // Access included data
     * const included = configStatusWithConfigs.included || [];
     * const configurations = included.filter(item => item.type === 'configurations');
     * console.log(`Found ${configurations.length} configurations with this status`);
     *
     * @example
     * // Error handling for get operations
     * try {
     *   const configStatus = await client.configurationStatuses.get('invalid-id');
     * } catch (error) {
     *   if (error.response?.status === 404) {
     *     console.log('Configuration status not found');
     *   } else if (error.response?.status === 403) {
     *     console.log('Access denied - insufficient permissions');
     *   } else {
     *     console.log('Error retrieving configuration status:', error.message);
     *   }
     * }
     *
     * @example
     * // Safe get with existence check
     * async function safeGetConfigurationStatus(id) {
     *   try {
     *     const configStatus = await client.configurationStatuses.get(id);
     *     return configStatus.data;
     *   } catch (error) {
     *     if (error.response?.status === 404) {
     *       return null; // Configuration status doesn't exist
     *     }
     *     throw error; // Re-throw other errors
     *   }
     * }
     */
    get(id: string, params?: QueryParams): Promise<BaseItemResponse<ConfigurationStatusResource>>;
    /**
     * Create a new configuration status
     * @param {RequestBody} data - Configuration status data (must be formatted according to JSON:API spec)
     * @returns {Promise<BaseItemResponse<ConfigurationStatusResource>>} Created configuration status resource
     * @example
     * // Basic creation with required fields
     * const newConfigStatus = await client.configurationStatuses.create({
     *   data: {
     *     type: 'configuration_statuses',
     *     attributes: {
     *       name: 'Under Maintenance',
     *       description: 'Equipment currently undergoing scheduled maintenance'
     *     }
     *   }
     * });
     *
     * console.log('Created configuration status with ID:', newConfigStatus.data.id);
     *
     * @example
     * // Advanced creation with color coding and visibility settings
     * const newConfigStatus = await client.configurationStatuses.create({
     *   data: {
     *     type: 'configuration_statuses',
     *     attributes: {
     *       name: 'Critical',
     *       description: 'Critical status requiring immediate attention and escalation',
     *       color: '#FF0000',
     *       show_in_summary: true,
     *       enabled: true
     *     }
     *   }
     * });
     *
     * @example
     * // Bulk creation with error handling
     * async function createMultipleConfigurationStatuses(statuses) {
     *   const results = [];
     *   const errors = [];
     *
     *   for (const statusData of statuses) {
     *     try {
     *       const created = await client.configurationStatuses.create({
     *         data: {
     *           type: 'configuration_statuses',
     *           attributes: statusData
     *         }
     *       });
     *       results.push(created.data);
     *     } catch (error) {
     *       errors.push({ statusData, error: error.message });
     *     }
     *   }
     *
     *   return { results, errors };
     * }
     *
     * // Usage
     * const statusesToCreate = [
     *   { name: 'Pending Deployment', description: 'Ready for deployment', color: '#FFA500' },
     *   { name: 'End of Life', description: 'Scheduled for decommissioning', color: '#800080' },
     *   { name: 'Testing', description: 'Under quality assurance testing', color: '#0000FF' }
     * ];
     *
     * @example
     * // Error handling for validation failures
     * try {
     *   const newConfigStatus = await client.configurationStatuses.create({
     *     data: {
     *       type: 'configuration_statuses',
     *       attributes: {
     *         // Missing required name field
     *         description: 'Missing name field'
     *       }
     *     }
     *   });
     * } catch (error) {
     *   if (error.response?.status === 422) {
     *     console.log('Validation errors:');
     *     error.response.data.errors.forEach(err => {
     *       console.log(`- ${err.detail} (${err.source?.pointer})`);
     *     });
     *   } else if (error.response?.status === 403) {
     *     console.log('Permission denied - cannot create configuration status');
     *   } else if (error.response?.status === 409) {
     *     console.log('Conflict - configuration status with this name already exists');
     *   } else {
     *     console.log('Creation failed:', error.message);
     *   }
     * }
     */
    create(data: RequestBody): Promise<BaseItemResponse<ConfigurationStatusResource>>;
    /**
     * Update a configuration status by ID
     * @param {string} id - Configuration status ID
     * @param {RequestBody} data - Updated configuration status data (must be formatted according to JSON:API spec)
     * @returns {Promise<BaseItemResponse<ConfigurationStatusResource>>} Updated configuration status resource
     * @example
     * // Basic update - modify specific fields
     * const updatedConfigStatus = await client.configurationStatuses.update('123', {
     *   data: {
     *     type: 'configuration_statuses',
     *     attributes: {
     *       name: 'Decommissioned',
     *       description: 'Equipment permanently removed from service'
     *     }
     *   }
     * });
     *
     * console.log('Updated configuration status:', updatedConfigStatus.data.attributes.name);
     *
     * @example
     * // Advanced update with color and visibility settings
     * const updatedConfigStatus = await client.configurationStatuses.update('123', {
     *   data: {
     *     type: 'configuration_statuses',
     *     attributes: {
     *       color: '#808080',
     *       show_in_summary: false,
     *       enabled: false,
     *       description: 'Legacy status - no longer in active use'
     *     }
     *   }
     * });
     *
     * @example
     * // Conditional update based on current state
     * async function conditionalUpdateConfigurationStatus(id, updates) {
     *   try {
     *     // First, get current state
     *     const current = await client.configurationStatuses.get(id);
     *
     *     // Check if update is needed
     *     const needsUpdate = Object.keys(updates).some(
     *       key => current.data.attributes[key] !== updates[key]
     *     );
     *
     *     if (!needsUpdate) {
     *       console.log('Configuration status is already up to date');
     *       return current;
     *     }
     *
     *     // Perform update
     *     return await client.configurationStatuses.update(id, {
     *       data: {
     *         type: 'configuration_statuses',
     *         attributes: updates
     *       }
     *     });
     *   } catch (error) {
     *     console.error('Update failed:', error.message);
     *     throw error;
     *   }
     * }
     *
     * @example
     * // Error handling for update operations
     * try {
     *   const updated = await client.configurationStatuses.update('123', {
     *     data: {
     *       type: 'configuration_statuses',
     *       attributes: {
     *         name: '' // Invalid empty name
     *       }
     *     }
     *   });
     * } catch (error) {
     *   if (error.response?.status === 404) {
     *     console.log('Configuration status not found');
     *   } else if (error.response?.status === 422) {
     *     console.log('Validation failed:', error.response.data.errors);
     *   } else if (error.response?.status === 409) {
     *     console.log('Conflict - configuration status may have been modified by another user');
     *   } else {
     *     console.log('Update failed:', error.message);
     *   }
     * }
     */
    update(id: string, data: RequestBody): Promise<BaseItemResponse<ConfigurationStatusResource>>;
    /**
     * Delete a configuration status by ID
     * @param {string} id - Configuration status ID
     * @returns {Promise<void>}
     * @example
     * // Basic deletion
     * await client.configurationStatuses.delete('123');
     * console.log('Configuration status deleted successfully');
     *
     * @example
     * // Safe deletion with confirmation
     * async function safeDeleteConfigurationStatus(id) {
     *   try {
     *     // First verify the configuration status exists
     *     const configStatus = await client.configurationStatuses.get(id);
     *     console.log(`Deleting configuration status: ${configStatus.data.attributes.name}`);
     *
     *     // Perform deletion
     *     await client.configurationStatuses.delete(id);
     *     console.log('Configuration status deleted successfully');
     *     return true;
     *   } catch (error) {
     *     if (error.response?.status === 404) {
     *       console.log('Configuration status not found - may already be deleted');
     *       return false;
     *     }
     *     throw error;
     *   }
     * }
     *
     * @example
     * // Bulk deletion with error handling
     * async function deleteMultipleConfigurationStatuses(ids) {
     *   const results = [];
     *
     *   for (const id of ids) {
     *     try {
     *       await client.configurationStatuses.delete(id);
     *       results.push({ id, status: 'deleted' });
     *     } catch (error) {
     *       results.push({
     *         id,
     *         status: 'error',
     *         error: error.response?.status === 404 ? 'not_found' : error.message
     *       });
     *     }
     *   }
     *
     *   return results;
     * }
     *
     * @example
     * // Error handling for delete operations
     * try {
     *   await client.configurationStatuses.delete('123');
     * } catch (error) {
     *   if (error.response?.status === 404) {
     *     console.log('Configuration status not found - may already be deleted');
     *   } else if (error.response?.status === 403) {
     *     console.log('Permission denied - cannot delete configuration status');
     *   } else if (error.response?.status === 409) {
     *     console.log('Cannot delete - configuration status is referenced by existing configurations');
     *   } else {
     *     console.log('Deletion failed:', error.message);
     *   }
     * }
     */
    delete(id: string): Promise<void>;
}