// This function is used to add configuration settings to imported audio assets.
        private void OnPreprocessAudio()
        {
            // Defining a new import configuration asset.
            ConfigurationAsset audioImportConfiguration;

            // Getting asset path directry in lower case type.
            string assetDirectory = AssetImportDirectory.GetAssetDirectory(assetImporter.assetPath.ToLower());

            // Getting import configuration asset file for the imported texture asset.
            audioImportConfiguration = Configurations.GetAssetImportConfiguration(assetDirectory);

            // Validating the import configuration asset.
            bool configurationAssetIsValid = AssetImportDirectory.IsValidConfigurationAsset(audioImportConfiguration);

            // Checking if import configurations asset file is valid.
            if (configurationAssetIsValid)
            {
                // Checking if the imported asset directories is included or affected by the configuration asset.
                if (audioImportConfiguration.IncludedAssetDirectoryLibrary.Directories.Contains(assetDirectory))
                {
                    // Post processing asset file using import settings.
                    AssetImporterPostProcessor.ProcessAudioAsset(audioImportConfiguration, this);

                    // Checking if the configuration asset allow debug is enabled.
                    if (audioImportConfiguration.AllowDebug)
                    {
                        // This message that will be logged to the unity's debug console.
                        string logMessage = "The imported audio asset(s) has been configured successfully.";

                        // Logging a new message to the unity debug console.
                        Debugger.Log(className: classLogName, message: logMessage);
                    }
                }
            }
        }
        /// <summary>
        /// Assigns asset directories to newly created configuration asset files.
        /// This static function also adds the project affected or included asset directories to a newly created configuration asset file.
        /// </summary>
        /// <param name="configurationAsset">Takes in the newly created configuration asset.</param>
        /// <param name="assetDirectory">Takes in the asset directory path.</param>
        public static void AddConfigurationIncludedAssetDirectory(ConfigurationAsset configurationAsset, string assetDirectory)
        {
            // Checking if asset importer configuration doesn't include any directories.
            bool configurationHasNoIncludedAssetDirectories = configurationAsset.GetIncludedAssetsDirectoryLibraryCount() <= 0;

            // Checking if asset importer configuration loaded successfully and that it doesn't include directories.
            if (AssetImportDirectory.IsValidConfigurationAsset(configurationAsset) && configurationHasNoIncludedAssetDirectories)
            {
                // Getting the directory of the newly created configuration asset.
                string newConfigurationAssetDirectory = AssetImportDirectory.GetAssetDirectory(assetDirectory);

                // Assigning the directory reference to the asset importer.
                configurationAsset.AddConfigurationAssetIncludedDirectoryToLibrary(newConfigurationAssetDirectory);

                // Checking for sub directories to include in the asset importer configuration directory.
                string[] subDirectoriesToInclude = AssetDatabase.GetSubFolders(newConfigurationAssetDirectory);

                // Checking if sun directories are found/initialized.
                bool subDirectoriesFound = subDirectoriesToInclude.Length > 0;

                // --Checking if sub directories were found in the asset directory.
                if (subDirectoriesFound)
                {
                    // Looping through found included sub directories to add to the asset importer configuration asset file.
                    foreach (string directory in subDirectoriesToInclude)
                    {
                        // Adding the scriptable object import configuration asset path to the newely created configuration asset file.
                        configurationAsset.AddConfigurationAssetIncludedDirectoryToLibrary(directory);
                    }
                }

                // Save asset data base.
                AssetDatabase.SaveAssets();

                // Refreshing the assets data base.
                AssetDatabase.Refresh();

                // Message to log in the unity debug console window.
                string logMessage = "A new import configuration asset file was successfully created at path : " + newConfigurationAssetDirectory;

                // Logging configuration asset creation successs message to the unity debugger console.
                Debugger.Log(className: classLogName, message: logMessage);
            }
        }
        private static void CreateImportConfiguration()
        {
            // Creating a new importer configuration asset file instance.
            ConfigurationAsset assetImportConfigurationAsset = CreateInstance <ConfigurationAsset>();

            // Getting the path to save newely created scriptable object import configuration asset.
            string importConfigurationAssetSavePath = EditorUtility.SaveFilePanelInProject("Asset Importer", "Asset Import Configuration", "asset", "");

            // Checking if the configuration asset save path exist.
            bool configurationAssetSavePathExist = !string.IsNullOrEmpty(importConfigurationAssetSavePath);

            // Checking if the importer configuration asset's instance was created.
            bool isConfigurationAssetCreated = assetImportConfigurationAsset != null;

            // Check if the importer configuration instance and the asset save path exist.
            if (isConfigurationAssetCreated && configurationAssetSavePathExist)
            {
                // Getting the selected import configuration asset directory where the configuration asset is created.
                string configurationAssetCreationDirectory = AssetImportDirectory.GetAssetDirectory(importConfigurationAssetSavePath);

                // Creating a new scriptable object import configuration asset to the import configuration path.
                AssetDatabase.CreateAsset(assetImportConfigurationAsset, importConfigurationAssetSavePath);

                // Save data base assets.
                AssetDatabase.SaveAssets();
            }
            else
            {
                // Warning message to log in the unity debug console window.
                string warningLogMessage = "Asset importer toolkit : Configuration file creation operation cancelled/failed: Import configuration asset file not created.";

                // Logging a new warning message to the console when the configuration asset file creation is cancelled by the user.
                Debugger.LogWarning(className: classLogName, message: warningLogMessage);

                return;
            }
        }